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;
int rideType;
rideEntry = GET_RIDE_ENTRY(entryGroupIndex);
rideEntry = get_ride_entry(entryGroupIndex);
for (int j = 0; j < 3; 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) {
vehicleEntry = &CableLiftVehicle;
} else {
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rideEntry = get_ride_entry(vehicle->ride_subtype);
vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
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;
}
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;
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;
rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) {
log_error("Attempted to paint invalid ride: %d", rideIndex);
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;
mapElement += 6;
ride = GET_RIDE(mapElement->type);
ride = get_ride(mapElement->type);
if (ride->status == RIDE_STATUS_CLOSED) {
RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 0, uint16) = 1163;
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)
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)
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;
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)
continue;
@ -295,7 +295,7 @@ static int award_is_deserved_best_food(int awardType, int activeAwardTypes)
continue;
shops++;
rideType = gRideTypeList[ride->subtype];
rideType = get_ride_entry(ride->subtype);
if (!(shopTypes & (1ULL << rideType->shop_item))) {
shopTypes |= (1ULL << rideType->shop_item);
uniqueShops++;
@ -341,7 +341,7 @@ static int award_is_deserved_worst_food(int awardType, int activeAwardTypes)
continue;
shops++;
rideType = gRideTypeList[ride->subtype];
rideType = get_ride_entry(ride->subtype);
if (!(shopTypes & (1ULL << rideType->shop_item))) {
shopTypes |= (1ULL << rideType->shop_item);
uniqueShops++;
@ -438,7 +438,7 @@ static int award_is_deserved_best_water_rides(int awardType, int activeAwardType
waterRides = 0;
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)
continue;
@ -538,7 +538,7 @@ static int award_is_deserved_best_gentle_rides(int awardType, int activeAwardTyp
gentleRides = 0;
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)
continue;

6
src/management/marketing.c
View File

@ -59,7 +59,7 @@ int marketing_get_campaign_guest_generation_probability(int campaign)
probability /= 8;
break;
case ADVERTISING_CAMPAIGN_RIDE_FREE:
ride = &g_ride_list[gMarketingCampaignRideIndex[campaign]];
ride = get_ride(gMarketingCampaignRideIndex[campaign]);
if (ride->price < 3)
probability /= 8;
break;
@ -94,7 +94,7 @@ void marketing_update()
// This sets the string parameters for the marketing types that have an argument.
if (campaign == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign == ADVERTISING_CAMPAIGN_RIDE) {
rct_ride* ride = GET_RIDE(campaignItem);
rct_ride* ride = get_ride(campaignItem);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
} 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:
// Check if any food or drink stalls exist
FOR_ALL_RIDES(i, ride) {
rideEntry = GET_RIDE_ENTRY(ride->subtype);
rideEntry = get_ride_entry(ride->subtype);
if (
shop_item_is_food_or_drink(rideEntry->shop_item) ||
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) {
case NEWS_ITEM_RIDE:
ride = &g_ride_list[subject];
ride = get_ride(subject);
if (ride->overall_view == 0xFFFF) {
*x = SPRITE_LOCATION_NULL;
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
ride = &g_ride_list[peep->current_ride];
ride = get_ride(peep->current_ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)) {
*x = SPRITE_LOCATION_NULL;
break;

12
src/management/research.c
View File

@ -177,7 +177,7 @@ void research_finish_item(sint32 entryIndex)
// Ride
base_ride_type = (entryIndex >> 8) & 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(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];
@ -189,7 +189,7 @@ void research_finish_item(sint32 entryIndex)
RCT2_ADDRESS(0x001357424, uint32)[rideEntryIndex >> 5] |= 1u << (rideEntryIndex & 0x1F);
if (!(rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)) {
for (i = 0; i < 128; i++) {
rideEntry2 = GET_RIDE_ENTRY(i);
rideEntry2 = get_ride_entry(i);
if (rideEntry2 == (rct_ride_type*)-1)
continue;
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 >= 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))) {
// Check if ride type already exists further up for a vehicle type that isn't displayed as a ride
researchItem2 = researchItem - 1;
@ -372,7 +372,7 @@ void research_remove_non_separate_vehicle_types()
researchItem2->entryIndex != RESEARCHED_ITEMS_SEPARATOR &&
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 (((researchItem->entryIndex >> 8) & 0xFF) == ((researchItem2->entryIndex >> 8) & 0xFF)) {
@ -484,7 +484,7 @@ void research_populate_list_random()
// Rides
for (int i = 0; i < 128; i++) {
rideEntry = GET_RIDE_ENTRY(i);
rideEntry = get_ride_entry(i);
if (rideEntry == (rct_ride_type*)-1)
continue;
@ -515,7 +515,7 @@ void research_populate_list_researched()
// Rides
for (int i = 0; i < 128; i++) {
rideEntry = GET_RIDE_ENTRY(i);
rideEntry = get_ride_entry(i);
if (rideEntry == (rct_ride_type*)-1)
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++;
break;
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 &&
ride->music_tune_id != 0xFF){
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);
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) ?
PEEP_THOUGHT_TYPE_GET_OUT :
@ -1075,7 +1075,7 @@ void peep_decrement_num_riders(rct_peep* peep){
if (peep->state == PEEP_STATE_ON_RIDE
|| peep->state == PEEP_STATE_ENTERING_RIDE){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
ride->num_riders--;
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);
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->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)
{
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
uint8 cur_station = peep->current_ride_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];
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 ||
ride_type->vehicles[ride_type->default_vehicle].flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
shift_multiplier = 32;
@ -1689,7 +1689,7 @@ static void peep_go_to_ride_entrance(rct_peep* peep, rct_ride* ride){
* rct2: 0x00691A3B
*/
static void peep_update_ride_sub_state_0(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
if (peep->destination_tolerence != 0){
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){
sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride_type* ride_entry = gRideTypeList[ride->subtype];
rct_ride* ride = get_ride(peep->current_ride);
rct_ride_type* ride_entry = get_ride_entry(ride->subtype);
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);
}
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];
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);
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];
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;
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];
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)){
@ -2205,7 +2205,7 @@ static void peep_update_ride_sub_state_2_rejoin_queue(rct_peep* peep, rct_ride*
* separate functions.
*/
static void peep_update_ride_sub_state_2(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)){
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);
}
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){
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){
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]);
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
*/
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]);
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;
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];
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;
}
ride_entry = GET_RIDE_ENTRY(ride->subtype);
ride_entry = get_ride_entry(ride->subtype);
vehicle_entry = &ride_entry->vehicles[ride_entry->default_vehicle];
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]);
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];
uint8 cl = peep->current_seat;
@ -2537,7 +2537,7 @@ void peep_update_ride_sub_state_7(rct_peep* peep){
* rct2: 0x0069376A
*/
static void peep_update_ride_prepare_for_state_9(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
sint16 x = ride->exits[peep->current_ride_station] & 0xFF;
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;
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];
if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
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){
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)){
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){
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)){
sint16 z;
@ -2679,7 +2679,7 @@ static void peep_update_ride_sub_state_12(rct_peep* peep){
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];
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){
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)){
sint16 z;
@ -2741,7 +2741,7 @@ static void peep_update_ride_sub_state_13(rct_peep* peep){
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];
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;
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];
if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
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){
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)){
invalidate_sprite_2((rct_sprite*)peep);
@ -2870,7 +2870,7 @@ static void peep_update_ride_sub_state_14(rct_peep* peep){
* rct2: 0x00692D83
*/
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)
return;
@ -2966,7 +2966,7 @@ static void peep_update_ride_sub_state_16(rct_peep* peep){
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) == 3){
@ -3035,7 +3035,7 @@ static void peep_update_ride_sub_state_17(rct_peep* peep){
return;
}
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
if (peep->var_37 == 16){
peep_update_ride_prepare_for_state_9(peep);
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){
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)){
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){
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 (peep->nausea <= 35){
@ -3309,7 +3309,7 @@ static void peep_update_ride_sub_state_21(rct_peep* peep){
peep->state = PEEP_STATE_WALKING;
peep_window_state_update(peep);
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
ride->total_customers++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
@ -3410,7 +3410,7 @@ static void peep_update_ride(rct_peep* peep){
* Also used by inspecting.
*/
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)
{
@ -3432,7 +3432,7 @@ static void peep_update_queuing(rct_peep* peep){
remove_peep_from_queue(peep);
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){
remove_peep_from_queue(peep);
peep_decrement_num_riders(peep);
@ -4142,7 +4142,7 @@ static void peep_update_buying(rct_peep* peep)
{
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){
peep_decrement_num_riders(peep);
peep->state = PEEP_STATE_FALLING;
@ -4194,7 +4194,7 @@ static void peep_update_buying(rct_peep* peep)
}
}
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){
money16 price = ride->price_secondary;
@ -4363,7 +4363,7 @@ static void peep_update_using_bin(rct_peep* peep){
* rct2: 0x006C16D7
*/
static void peep_update_heading_to_inspect(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL){
peep_decrement_num_riders(peep);
@ -4472,7 +4472,7 @@ static void peep_update_heading_to_inspect(rct_peep* peep){
* rct2: 0x006C0CB8
*/
static void peep_update_answering(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride);
rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL ||
ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING){
@ -5225,7 +5225,7 @@ void peep_problem_warnings_update()
hunger_counter++;
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))
hunger_counter++;
break;
@ -5235,7 +5235,7 @@ void peep_problem_warnings_update()
thirst_counter++;
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))
thirst_counter++;
break;
@ -5245,7 +5245,7 @@ void peep_problem_warnings_update()
bathroom_counter++;
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))
bathroom_counter++;
break;
@ -5630,7 +5630,7 @@ rct_peep *peep_generate(int x, int y, int z)
* argument_2 (edx)
*/
void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argument_2){
rct_ride ride;
rct_ride *ride;
switch (peep->state){
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_ENTERING_RIDE:
*argument_1 = STR_ON_RIDE;
ride = g_ride_list[peep->current_ride];
if (ride_type_has_flag(ride.type, RIDE_TYPE_FLAG_IN_RIDE))
ride = get_ride(peep->current_ride);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE))
*argument_1 = STR_IN_RIDE;
*argument_1 |= (ride.name << 16);
*argument_2 = ride.name_arguments;
*argument_1 |= (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
case PEEP_STATE_BUYING:
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_AT_RIDE | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_AT_RIDE | (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
case PEEP_STATE_WALKING:
case PEEP_STATE_USING_BIN:
if (peep->guest_heading_to_ride_id != 0xFF){
ride = g_ride_list[peep->guest_heading_to_ride_id];
*argument_1 = STR_HEADING_FOR | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->guest_heading_to_ride_id);
*argument_1 = STR_HEADING_FOR | (ride->name << 16);
*argument_2 = ride->name_arguments;
}
else{
*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;
case PEEP_STATE_QUEUING_FRONT:
case PEEP_STATE_QUEUING:
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_QUEUING_FOR | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_QUEUING_FOR | (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
case PEEP_STATE_SITTING:
*argument_1 = STR_SITTING;
@ -5680,13 +5680,13 @@ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argum
break;
case PEEP_STATE_WATCHING:
if (peep->current_ride != 0xFF){
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_WATCHING_RIDE | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_WATCHING_RIDE | (ride->name << 16);
*argument_2 = ride->name_arguments;
if (peep->current_seat & 0x1)
*argument_1 = STR_WATCHING_CONSTRUCTION_OF | (ride.name << 16);
*argument_1 = STR_WATCHING_CONSTRUCTION_OF | (ride->name << 16);
else
*argument_1 = STR_WATCHING_RIDE | (ride.name << 16);
*argument_1 = STR_WATCHING_RIDE | (ride->name << 16);
}
else{
*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;
}
else{
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_RESPONDING_TO_RIDE_BREAKDOWN_CALL | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_RESPONDING_TO_RIDE_BREAKDOWN_CALL | (ride->name << 16);
*argument_2 = ride->name_arguments;
}
break;
case PEEP_STATE_FIXING:
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_FIXING_RIDE | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_FIXING_RIDE | (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
case PEEP_STATE_HEADING_TO_INSPECTION:
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_HEADING_TO_RIDE_FOR_INSPECTION | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_HEADING_TO_RIDE_FOR_INSPECTION | (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
case PEEP_STATE_INSPECTING:
ride = g_ride_list[peep->current_ride];
*argument_1 = STR_INSPECTING_RIDE | (ride.name << 16);
*argument_2 = ride.name_arguments;
ride = get_ride(peep->current_ride);
*argument_1 = STR_INSPECTING_RIDE | (ride->name << 16);
*argument_2 = ride->name_arguments;
break;
}
@ -5765,7 +5765,7 @@ void get_arguments_from_thought(rct_peep_thought thought, uint32* argument_1, ui
int esi = 0x009AC86C;
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));
} else if ((RCT2_ADDRESS(0x00981DB1, uint16)[thought.type] & 0xFF) & 2) {
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->var_79 = rideIndex;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
uint16 previous_last = ride->last_peep_in_queue[stationNum];
ride->last_peep_in_queue[stationNum] = peep->sprite_index;
peep->next_in_queue = previous_last;
@ -6680,7 +6680,7 @@ static int peep_interact_with_path(rct_peep* peep, sint16 x, sint16 y, rct_map_e
}
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];
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){
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))
return 0;
@ -7002,7 +7002,7 @@ static uint8 loc_6949B9(
case MAP_ELEMENT_TYPE_TRACK:
if (z != mapElement->base_height) continue;
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)) {
*outRideIndex = rideIndex;
return PATH_SEARCH_RIDE_ENTRANCE;
@ -7677,7 +7677,7 @@ static int guest_path_finding(rct_peep* peep)
return guest_path_find_aimless(peep, edges);
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)
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)
{
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);
}
@ -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)
{
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.
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (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)
{
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
money32 value;
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 (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->cur_num_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)
{
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)
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (peepAtRide) {
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
ride->lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL;
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
// Peeps won't go to the same shop twice in a row.
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))))
continue;
rct_ride *ride = GET_RIDE(i);
rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i;
@ -9165,7 +9165,7 @@ static void peep_pick_ride_to_go_on(rct_peep *peep)
int mostExcitingRideIndex = -1;
ride_rating mostExcitingRideRating = 0;
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 > mostExcitingRideRating) {
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->x == (sint16)0x8000) return;
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) {
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;
int rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == rideType) {
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))))
continue;
rct_ride *ride = GET_RIDE(i);
rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i;
@ -9274,7 +9274,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, int rideType)
int closestRideIndex = -1;
int closestRideDistance = INT_MAX;
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 rideY = (ride->station_starts[0] >> 8) * 32;
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->x == (sint16)0x8000) return;
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)) {
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;
int rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, rideTypeFlags)) {
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))))
continue;
rct_ride *ride = GET_RIDE(i);
rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i;
@ -9386,7 +9386,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, int rideTypeFl
int closestRideIndex = -1;
int closestRideDistance = INT_MAX;
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 rideY = (ride->station_starts[0] >> 8) * 32;
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++) {
rideMeasurement = GET_RIDE_MEASUREMENT(i);
rideMeasurement = get_ride_measurement(i);
if (rideMeasurement->ride_index == 255)
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_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
rct_vehicle *current = &(create_sprite(1)->vehicle);
current->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
current->ride = rideIndex;
@ -200,7 +200,7 @@ static void cable_lift_update_arriving(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);
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) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
rct_xyz16 *unk_F64E20 = RCT2_ADDRESS(0x00F64E20, rct_xyz16);
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)
{
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* ride = GET_RIDE(cableLift->ride);
rct_ride* ride = get_ride(cableLift->ride);
RCT2_GLOBAL(0x00F64E2C, uint8) = 0;
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* 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;
int gRideRemoveTrackPieceCallbackX;
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 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)
{
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)
return;
if (peep->favourite_ride != 0xff) {
ride = &g_ride_list[peep->favourite_ride];
ride = &gRideList[peep->favourite_ride];
ride->guests_favourite++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
@ -279,7 +304,7 @@ money32 ride_calculate_income_per_hour(rct_ride *ride)
money32 customersPerHour, priceMinusCost;
int currentShopItem;
entry = GET_RIDE_ENTRY(ride->subtype);
entry = get_ride_entry(ride->subtype);
customersPerHour = ride_customers_per_hour(ride);
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)
{
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D3, uint8) = direction_start;
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;
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);
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
*/
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;
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;
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);
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;
rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE)
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)
{
rct_ride *ride = &g_ride_list[rideIndex];
rct_ride *ride = get_ride(rideIndex);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED) {
*formatSecondary = STR_CRASHED;
@ -762,7 +787,7 @@ void ride_init_all()
rct_ride_measurement *ride_measurement;
for (i = 0; i < MAX_RIDES; i++) {
ride = &g_ride_list[i];
ride = get_ride(i);
ride->type = RIDE_TYPE_NULL;
}
@ -770,7 +795,7 @@ void ride_init_all()
RCT2_GLOBAL(0x0138B591, sint8) = 0;
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;
}
}
@ -943,7 +968,7 @@ void ride_clear_for_construction(int rideIndex)
rct_ride *ride;
rct_window *w;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
ride_measurement_clear(ride);
@ -970,7 +995,7 @@ void ride_remove_peeps(int rideIndex)
rct_map_element *mapElement;
rct_peep *peep;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
// Find first station
stationIndex = -1;
@ -1225,7 +1250,7 @@ void sub_6C96C0()
y = RCT2_GLOBAL(0x00F440C7, uint16);
z = RCT2_GLOBAL(0x00F440C9, uint16);
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
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 | (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;
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15) || ride->num_stations == 0) {
_currentTrackCurve = RCT2_GLOBAL(0x0097CC68 + (ride->type * 2), uint8) | 0x100;
_currentTrackSlopeEnd = 0;
@ -1338,7 +1363,7 @@ void ride_construction_set_default_next_piece()
switch (_rideConstructionState) {
case RIDE_CONSTRUCTION_STATE_FRONT:
rideIndex = _currentRideIndex;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
x = _currentTrackBeginX;
@ -1395,7 +1420,7 @@ void ride_construction_set_default_next_piece()
break;
case RIDE_CONSTRUCTION_STATE_BACK:
rideIndex = _currentRideIndex;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
x = _currentTrackBeginX;
@ -1644,7 +1669,7 @@ int ride_modify(rct_xy_element *input)
mapElement = *input;
rideIndex = mapElement.element->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (!ride_check_if_construction_allowed(ride))
return 0;
@ -1739,7 +1764,7 @@ int sub_6CC3FB(int rideIndex)
rct_window *w;
tool_cancel();
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (!ride_check_if_construction_allowed(ride))
return 0;
@ -1752,7 +1777,7 @@ int sub_6CC3FB(int rideIndex)
tool_set(w, 23, 12);
gInputFlags |= INPUT_FLAG_6;
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
_currentTrackCurve = RCT2_ADDRESS(0x0097CC68, uint8)[ride->type * 2] | 0x100;
_currentTrackSlopeEnd = 0;
@ -1815,7 +1840,7 @@ void ride_update_all()
static void ride_update(int rideIndex)
{
int i;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (ride->var_1CA != 0)
ride->var_1CA--;
@ -2076,7 +2101,7 @@ static int get_age_penalty(rct_ride *ride) {
static void ride_breakdown_update(int rideIndex)
{
int breakdownReason, unreliabilityAccumulator;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) & 255)
return;
@ -2203,7 +2228,7 @@ void ride_prepare_breakdown(int rideIndex, int breakdownReason)
rct_ride *ride;
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))
return;
@ -2275,7 +2300,7 @@ void ride_prepare_breakdown(int rideIndex, int breakdownReason)
*/
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 + 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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
// Warn player if ride hasnt been fixed for ages
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_peep *mechanic;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
switch (mechanicStatus) {
case RIDE_MECHANIC_STATUS_UNDEFINED:
breakdownReason = ride->breakdown_reason_pending;
@ -2387,7 +2412,7 @@ static void ride_call_mechanic(int rideIndex, rct_peep *mechanic, int forInspect
{
rct_ride *ride;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
peep_decrement_num_riders(mechanic);
mechanic->state = forInspection ? PEEP_STATE_HEADING_TO_INSPECTION : PEEP_STATE_ANSWERING;
peep_window_state_update(mechanic);
@ -2409,7 +2434,7 @@ static void ride_call_closest_mechanic(int rideIndex)
rct_peep *mechanic;
int forInspection;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
forInspection = (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)) == 0;
mechanic = ride_find_closest_mechanic(ride, forInspection);
@ -2570,7 +2595,7 @@ static void ride_music_update(int rideIndex)
{
int x, y, z;
rct_vehicle *vehicle;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (
!(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)
return;
measurement = GET_RIDE_MEASUREMENT(ride->measurement_index);
measurement = get_ride_measurement(ride->measurement_index);
measurement->ride_index = 255;
ride->measurement_index = 255;
}
@ -2672,7 +2697,7 @@ void ride_measurement_update(rct_ride_measurement *measurement)
rct_vehicle *vehicle;
int velocity, altitude, verticalG, lateralG;
ride = GET_RIDE(measurement->ride_index);
ride = get_ride(measurement->ride_index);
spriteIndex = ride->vehicles[measurement->vehicle_index];
if (spriteIndex == SPRITE_INDEX_NULL)
return;
@ -2754,11 +2779,11 @@ void ride_measurements_update()
// For each ride measurement
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i);
measurement = get_ride_measurement(i);
if (measurement->ride_index == 255)
continue;
ride = GET_RIDE(measurement->ride_index);
ride = get_ride(measurement->ride_index);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
continue;
@ -2792,7 +2817,7 @@ rct_ride_measurement *ride_get_existing_measurement(int rideIndex)
rct_ride_measurement *measurement;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i);
measurement = get_ride_measurement(i);
if (measurement->ride_index == rideIndex)
return measurement;
}
@ -2806,7 +2831,7 @@ int ride_get_free_measurement()
rct_ride_measurement *measurement;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i);
measurement = get_ride_measurement(i);
if (measurement->ride_index == 255)
return i;
}
@ -2825,7 +2850,7 @@ rct_ride_measurement *ride_get_measurement(int rideIndex, rct_string_id *message
uint32 lruTicks;
int i, lruIndex;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
// Check if ride type supports 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;
lruTicks = 0xFFFFFFFF;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i);
measurement = get_ride_measurement(i);
if (measurement->last_use_tick <= lruTicks) {
lruTicks = measurement->last_use_tick;
@ -2852,10 +2877,10 @@ rct_ride_measurement *ride_get_measurement(int rideIndex, rct_string_id *message
}
i = lruIndex;
measurement = GET_RIDE_MEASUREMENT(i);
GET_RIDE(measurement->ride_index)->measurement_index = 255;
measurement = get_ride_measurement(i);
get_ride(measurement->ride_index)->measurement_index = 255;
} else {
measurement = GET_RIDE_MEASUREMENT(i);
measurement = get_ride_measurement(i);
}
measurement->ride_index = rideIndex;
@ -2919,7 +2944,7 @@ static int ride_get_unused_preset_vehicle_colour(uint8 ride_type, uint8 ride_sub
{
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)
{
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)
{
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;
if (presetList->count != 255) {
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;
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)) {
entrance_directions = RCT2_ADDRESS(0x0099CA64, uint8)[track_type * 16];
} else {
@ -3135,7 +3160,7 @@ static void ride_track_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride;
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 + 2, uint16) = ride->name;
@ -3153,7 +3178,7 @@ static void ride_station_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride;
rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
stationIndex = map_get_station(mapElement);
for (i = stationIndex; i >= 0; i--)
@ -3179,7 +3204,7 @@ static void ride_entrance_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride;
rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
// Get the station
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;
return;
}
rct_ride* ride = GET_RIDE(ride_id);
rct_ride* ride = get_ride(ride_id);
if (ride->type == RIDE_TYPE_NULL)
{
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_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);
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)
{
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
return 1;
@ -3835,7 +3860,7 @@ int ride_check_for_entrance_exit(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++) {
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;
rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE)
return true;
@ -3955,7 +3980,7 @@ bool ride_check_track_contains_banked(rct_xy_element *input, rct_xy_element *out
track_circuit_iterator it;
rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE)
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;
rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
w = window_find_by_class(WC_RIDE_CONSTRUCTION);
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
switch (ride->type) {
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED &&
ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT
@ -4525,7 +4550,7 @@ void loc_6B51C0(int rideIndex)
rct_xy_element trackElement;
rct_window *w;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (RCT2_GLOBAL(0x0141F568, uint8) != RCT2_GLOBAL(0x013CA740, uint8))
return;
@ -4578,7 +4603,7 @@ void loc_6B528A(rct_xy_element *trackElement)
rct_ride *ride;
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))
return;
@ -4626,7 +4651,7 @@ int ride_is_valid_for_test(int rideIndex, int goingToBeOpen, int isApplying)
rct_ride *ride;
rct_xy_element trackElement, problematicTrackElement;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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) {
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) {
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN;
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_xy_element trackElement, problematicTrackElement;
ride = GET_RIDE(rideIndex);
ride = get_ride(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) {
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) {
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN;
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;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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;
}
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
log_warning("Invalid game command for ride %u", rideIndex);
@ -5151,7 +5176,7 @@ static int ride_get_empty_slot()
{
rct_ride *ride;
for (int i = 0; i < MAX_RIDES; i++) {
ride = GET_RIDE(i);
ride = get_ride(i);
if (ride->type == RIDE_TYPE_NULL) {
return i;
}
@ -5161,7 +5186,7 @@ static int ride_get_empty_slot()
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;
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) {
if (ride != forRide) {
rideEntry = GET_RIDE_ENTRY(ride->subtype);
rideEntry = get_ride_entry(ride->subtype);
if (rideEntry->shop_item == shopItem) {
return ride->price;
}
@ -5314,7 +5339,7 @@ money32 ride_create(int type, int subType, int flags, int *outRideIndex, int *ou
if (subType == 255) {
uint8 *availableRideEntries = get_ride_entry_indices_for_ride_type(type);
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)) {
subType = *rei;
goto foundRideEntry;
@ -5351,8 +5376,8 @@ foundRideEntry:
return 0;
}
ride = GET_RIDE(rideIndex);
rideEntry = GET_RIDE_ENTRY(rideEntryIndex);
ride = get_ride(rideIndex);
rideEntry = get_ride_entry(rideEntryIndex);
if (rideEntry == (rct_ride_type *)0xFFFFFFFF)
{
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_Y, 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)
{
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;
}
rct_ride *ride = GET_RIDE(ride_id);
rct_ride *ride = get_ride(ride_id);
if (ride->type == RIDE_TYPE_NULL) {
log_warning("Invalid game command, ride_id = %u", ride_id);
*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;
return;
}
ride = GET_RIDE(ride_number);
ride = get_ride(ride_number);
if (ride->type == RIDE_TYPE_NULL)
{
log_warning("Invalid game command for ride %u", ride_number);
*ebx = MONEY32_UNDEFINED;
return;
}
rideEntry = GET_RIDE_ENTRY(ride->subtype);
rideEntry = get_ride_entry(ride->subtype);
price = *edi;
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;
}
}
ride = GET_RIDE(0);
rideEntry = GET_RIDE_ENTRY(ride->subtype);
ride = get_ride(0);
rideEntry = get_ride_entry(ride->subtype);
uint8 count = 0;
while (count < 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++;
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)];
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
ride_measurement_clear(ride);
ride->excitement = 0xFFFF;
@ -6696,7 +6721,7 @@ void invalidate_test_results(int rideIndex)
*/
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_BROKEN_DOWN;
@ -6735,7 +6760,7 @@ static void ride_update_vehicle_colours(int rideIndex)
uint16 spriteIndex;
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)) {
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)
{
rct_ride_type *rideEntry = GET_RIDE_ENTRY(rideEntryIndex);
rct_ride_type *rideEntry = get_ride_entry(rideEntryIndex);
for (int i = 0; i < numCarsPerTrain; i++) {
uint8 vehicleType = rideEntry->default_vehicle;
@ -6870,11 +6895,11 @@ void ride_update_max_vehicles(int rideIndex)
uint8 trainLayout[16], numCarsPerTrain, numVehicles;
int trainLength, maxNumTrains;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->subtype == 0xFF)
return;
rideEntry = GET_RIDE_ENTRY(ride->subtype);
rideEntry = get_ride_entry(ride->subtype);
if (rideEntry->cars_per_flat_ride == 0xFF) {
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);
@ -7051,7 +7076,7 @@ void game_command_set_ride_vehicles(int *eax, int *ebx, int *ecx, int *edx, int
}
value = (*edx >> 8) & 0xFF;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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;
case RIDE_SET_VEHICLES_COMMAND_TYPE_NUM_CARS_PER_TRAIN:
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);
ride->var_0CB = value;
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);
return MONEY32_UNDEFINED;
}
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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);
return MONEY32_UNDEFINED;
}
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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_window *w;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
vehicle = GET_VEHICLE(ride->vehicles[vehicleIndex]);
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_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. */
#define GET_RIDE(x) (&g_ride_list[x])
#define GET_RIDE_MEASUREMENT(x) (&(RCT2_ADDRESS(RCT2_ADDRESS_RIDE_MEASUREMENTS, rct_ride_measurement)[x]))
#define GET_RIDE_ENTRY(x) gRideTypeList[x]
rct_ride *get_ride(int index);
rct_ride_type *get_ride_entry(int index);
rct_ride_measurement *get_ride_measurement(int index);
/**
* Helper macro loop for enumerating through all the non null rides.
*/
#define FOR_ALL_RIDES(i, ride) \
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];

14
src/ride/ride_ratings.c
View File

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

36
src/ride/track.c
View File

@ -359,8 +359,8 @@ void track_list_populate(ride_list_item item, uint8* track_list_cache){
}
else{
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)) &&
!rideTypeShouldLoseSeparateFlag(GET_RIDE_ENTRY(entry_index)))
if ((get_ride_entry(entry_index)->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME | RIDE_ENTRY_FLAG_SEPARATE_RIDE)) &&
!rideTypeShouldLoseSeparateFlag(get_ride_entry(entry_index)))
continue;
}
else{
@ -408,7 +408,7 @@ void track_load_list(ride_list_item item)
RCT2_GLOBAL(0xF635ED, uint8) = 0;
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)){
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){
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);
ride->type = RIDE_TYPE_NULL;
}
@ -2027,7 +2027,7 @@ int sub_6D2189(int* cost, uint8* ride_id){
// bh
*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);
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
*/
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);
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;
}
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
uint16 location = ride->entrances[0];
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)
{
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
rct_xy_element trackElement;
track_begin_end trackBeginEnd;
@ -2933,7 +2933,7 @@ int tracked_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* tra
* rct2: 0x006CE44F
*/
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);
track_design->type = ride->type;
@ -3039,7 +3039,7 @@ int save_track_to_file(rct_track_td6* track_design, char* path)
* rct2: 0x006D2804, 0x006D264D
*/
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)){
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;
}
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
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
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)
{
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)
{
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype);
rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_map_element *mapElement;
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(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);
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)
{
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;
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;
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 bankStart = gTrackDefinitions[trackType].bank_start;
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;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(ride->subtype);
rct_ride* ride = get_ride(rideIndex);
rct_ride_type* rideEntry = get_ride_entry(ride->subtype);
rct_vehicle* vehicle = NULL;
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);
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) {
@ -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);
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) {
@ -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);
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) {
@ -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);
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) {
@ -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);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc =
((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);
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) {
@ -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);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc =
((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);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc =
((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(0x0141E9D4, sint16) = -1;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype);
rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];
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(0x0141E9D4, sint16) = -1;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype);
rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];
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;
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;
if (test & 1) {
@ -584,7 +584,7 @@ void vehicle_update_all()
* @returns 0 when all closed
*/
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;
uint16 vehicle_id = vehicle->sprite_index;
@ -646,8 +646,8 @@ static int vehicle_open_restraints(rct_vehicle* vehicle){
vehicle->var_4E = 0;
vehicle->var_4A = 0;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_SPINNING) {
@ -737,7 +737,7 @@ static void vehicle_update_measurements(rct_vehicle *vehicle)
{
rct_ride *ride;
ride = GET_RIDE(vehicle->ride);
ride = get_ride(vehicle->ride);
if (vehicle->status == VEHICLE_STATUS_TRAVELLING_BOAT){
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@ -1091,11 +1091,11 @@ static void vehicle_update(rct_vehicle *vehicle)
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];
ride = GET_RIDE(vehicle->ride);
ride = get_ride(vehicle->ride);
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_TESTING)
vehicle_update_measurements(vehicle);
@ -1193,7 +1193,7 @@ static void vehicle_update(rct_vehicle *vehicle)
* rct2: 0x006D7BCC
*/
static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
int eax, ebx;
switch (ride->mode){
@ -1239,7 +1239,7 @@ static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){
break;
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];
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)
return;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (ride->status == RIDE_STATUS_OPEN &&
!(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){
vehicle->velocity = 0;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (vehicle->sub_state == 0){
if (vehicle_open_restraints(vehicle))
@ -1529,8 +1529,8 @@ static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){
* rct2: 0x006D91BF
*/
static void vehicle_update_bumpcar_mode(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
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
*/
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;
if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) {
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;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS)) {
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)
{
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride *ride = get_ride(vehicle->ride);
int station = vehicle->current_station;
uint16 xy = ride->station_starts[station];
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++) {
rct_vehicle *v = GET_VEHICLE(ride->vehicles[i]);
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;
}
ride = GET_RIDE(someRideIndex);
ride = get_ride(someRideIndex);
int numAdjacentTrainsAtStation = 0;
int numTravelingTrains = 0;
int currentStation = vehicle->current_station;
@ -1998,7 +1998,7 @@ void vehicle_peep_easteregg_here_we_are(rct_vehicle* vehicle) {
* rct2: 0x006D7338
*/
void vehicle_update_test_finish(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_TESTING;
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@ -2034,7 +2034,7 @@ void vehicle_update_test_finish(rct_vehicle* vehicle) {
void vehicle_test_reset(rct_vehicle* vehicle) {
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_TESTING;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags |= RIDE_LIFECYCLE_TEST_IN_PROGRESS;
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_NO_RAW_STATS;
ride->max_speed = 0;
@ -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) {
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;
uint8 waitingTime = max(ride->min_waiting_time, 3);
@ -2141,8 +2141,8 @@ static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) {
* rct2: 0x006D845B
*/
static void vehicle_update_departing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
if (vehicle->sub_state == 0) {
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) {
@ -2354,7 +2354,7 @@ static void vehicle_update_departing(rct_vehicle* vehicle) {
* rct2: 0x006D8858
*/
static void vehicle_finish_departing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (ride->mode == RIDE_MODE_DOWNWARD_LAUNCH ) {
if (vehicle->var_CE >= 1 && (14 << 16) > vehicle->velocity)
@ -2406,7 +2406,7 @@ static void vehicle_finish_departing(rct_vehicle* vehicle) {
* rct2: 0x006DE5CB
*/
static void vehicle_check_if_missing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
return;
@ -2456,7 +2456,7 @@ static void vehicle_update_collision_setup(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
while (frontVehicle->is_child != 0)frontVehicle = GET_VEHICLE(frontVehicle->prev_vehicle_on_ride);
@ -2593,7 +2593,7 @@ static void vehicle_update_crash_setup(rct_vehicle* vehicle) {
static void vehicle_update_travelling(rct_vehicle* vehicle) {
vehicle_check_if_missing(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0 && ride->mode == RIDE_MODE_ROTATING_LIFT)
return;
@ -2763,7 +2763,7 @@ static void vehicle_update_travelling(rct_vehicle* vehicle) {
*/
static void vehicle_update_arriving(rct_vehicle* vehicle) {
RCT2_GLOBAL(0x00F64E35, uint8) = 1;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
switch (ride->mode) {
case RIDE_MODE_SWING:
@ -2797,7 +2797,7 @@ static void vehicle_update_arriving(rct_vehicle* vehicle) {
ride->mechanic_status != RIDE_MECHANIC_STATUS_4)
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];
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 ||
ride->mode == RIDE_MODE_BACKWARD_ROTATION) {
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)
{
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
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
*/
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->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];
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
);
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride *ride = get_ride(vehicle->ride);
vehicle->track_type =
(mapElement->properties.track.type << 2) |
(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 (vehicle_is_boat_on_water(vehicle, x, y)) {
// loc_6DA939:
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride *ride = get_ride(vehicle->ride);
bool do_loc_6DAA97 = false;
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)
{
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
rct_xy8 location = {
.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 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)) {
location = *((rct_xy8*)&ride->boat_hire_return_position);
rct_xy16 destLocation = {
@ -3519,8 +3519,8 @@ static bool vehicle_is_boat_on_water(rct_vehicle *vehicle, int x, int y)
* rct2: 0x006D9249
*/
static void vehicle_update_swinging(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
// SubState for this ride means swinging state
// 0 == first swing
@ -3584,7 +3584,7 @@ static void vehicle_update_ferris_wheel_rotating(rct_vehicle* vehicle) {
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0)
return;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if ((vehicle->ferris_wheel_var_1 -= 1) != 0)
return;
@ -3693,8 +3693,8 @@ static void vehicle_update_rotating(rct_vehicle* vehicle) {
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0)
return;
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
uint8* edi;
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;
}
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = numFatalities;
uint8 crashType = numFatalities == 0 ?
@ -4060,7 +4060,7 @@ static void vehicle_crash_on_land(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
@ -4111,7 +4111,7 @@ static void vehicle_crash_on_water(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride);
rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
@ -4259,8 +4259,8 @@ static void vehicle_update_sound(rct_vehicle *vehicle)
uint8 screamId, screamVolume = 255;
uint16 soundIdVolume;
ride = GET_RIDE(vehicle->ride);
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
ride = get_ride(vehicle->ride);
rideEntry = get_ride_entry(vehicle->ride_subtype);
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_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];
@ -4961,7 +4961,7 @@ void vehicle_set_map_toolbar(rct_vehicle *vehicle)
rct_ride *ride;
int vehicleIndex;
ride = GET_RIDE(vehicle->ride);
ride = get_ride(vehicle->ride);
while (vehicle->is_child) {
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) {
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;
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;
eax += edx;
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];
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)
{
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
// 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;
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)) {
audio_play_sound_at_location(SOUND_48, x, y, z);
}
@ -6084,7 +6084,7 @@ static void sub_6D63D4(rct_vehicle *vehicle)
al &= 0x02;
ah &= 0x02;
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 ||
(vehicle->status != VEHICLE_STATUS_MOVING_TO_END_OF_STATION &&
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)
{
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;
if (!(rideEntry->flags & RIDE_ENTRY_FLAG_8)) {
@ -6769,7 +6769,7 @@ loc_6DB358:
// Update VEHICLE_UPDATE_FLAG_11 flag
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 (mapElement->properties.track.colour & 4) {
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) {
registers regs = { 0 };
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
rct_map_element *mapElement = NULL;
@ -7470,7 +7470,7 @@ loc_6DC476:
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;
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (mapElement->properties.track.colour & (1 << 2)) {
@ -7682,7 +7682,7 @@ loc_6DCA9A:
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;
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (mapElement->properties.track.colour & (1 << 2)) {
@ -7973,8 +7973,8 @@ int vehicle_update_track_motion(rct_vehicle *vehicle, int *outStation)
//return regs.eax;
//////////////////////////////////////////////////////////////////////////////////////////
rct_ride *ride = GET_RIDE(vehicle->ride);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
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 *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype);
rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
return &rideEntry->vehicles[vehicle->vehicle_type];
}
@ -8316,7 +8316,7 @@ void vehicle_invalidate_window(rct_vehicle *vehicle)
if (w == NULL)
return;
ride = GET_RIDE(vehicle->ride);
ride = get_ride(vehicle->ride);
viewVehicleIndex = w->ride.view - 1;
if (viewVehicleIndex < 0 || viewVehicleIndex >= ride->num_vehicles)
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;
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;
count++;
@ -805,7 +805,7 @@ int scenario_write_packed_objects(SDL_RWops* rw)
int i;
rct_object_entry_extended *entry = (rct_object_entry_extended*)0x00F3F03C;
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;
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 *dstEntry = (rct_object_entry*)buffer;
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));
else
*dstEntry = *((rct_object_entry*)srcEntry);
@ -993,7 +993,7 @@ int scenario_save(SDL_RWops* rw, int flags)
for (int i = 0; i < 721; 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));
} else {
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++) {
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));
} else {
s6->objects[i] = *((rct_object_entry*)entry);
@ -1263,7 +1263,7 @@ static void scenario_objective_check_10_rollercoasters()
FOR_ALL_RIDES(i, ride) {
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) &&
ride->status == RIDE_STATUS_OPEN &&
@ -1340,7 +1340,7 @@ static void scenario_objective_check_10_rollercoasters_length()
FOR_ALL_RIDES(i, ride) {
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) &&
ride->status == RIDE_STATUS_OPEN &&
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);
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 + 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
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;
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 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;
if (!(ride_entry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)){
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)
continue;
@ -316,7 +316,7 @@ static rct_string_id research_item_get_name(uint32 researchItem)
return sceneryEntry->name;
}
rideEntry = GET_RIDE_ENTRY(researchItem & 0xFF);
rideEntry = get_ride_entry(researchItem & 0xFF);
if (rideEntry == NULL || rideEntry == (rct_ride_type*)0xFFFFFFFF)
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));
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)
continue;
@ -1955,7 +1955,7 @@ static void window_editor_object_selection_manage_tracks()
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];
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)
return;
ride = GET_RIDE(i);
ride = get_ride(i);
ride->lifecycle_flags ^= RIDE_LIFECYCLE_INDESTRUCTIBLE;
window_invalidate(w);
}
@ -1208,7 +1208,7 @@ static void window_editor_objective_options_rides_scrollpaint(rct_window *w, rct
}
// Checkbox mark
ride = GET_RIDE(i);
ride = get_ride(i);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE) {
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);

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) {
case ADVERTISING_CAMPAIGN_RIDE_FREE:
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 + 2, uint32) = ride->name_arguments;
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_offset = ride_id / 8;
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){
w->list_item_positions[curr_list_position] = ride_id;
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_arguments = 0;
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_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);
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);
}
@ -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;
break;
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 + 8, uint32) = ride->name_arguments;
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);
break;
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 + 8, uint16) = ride->name;
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;
break;
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 + 8, uint32) = ride->name_arguments;
break;
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 + 8, uint32) = ride->name_arguments;
break;
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 + 8, uint32) = ride->name_arguments;
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;
if (type != 3) { // common for cases 0, 1, 2
ride = GET_RIDE(index & 0x000000FF);
ride = get_ride(index & 0x000000FF);
eax = ride->name;
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;
// fall-through
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]];
break;
}

6
src/windows/maze_construction.c
View File

@ -176,7 +176,7 @@ static void window_maze_construction_close(rct_window *w)
hide_gridlines();
uint8 rideIndex = _currentRideIndex;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride->overall_view == 0xFFFF) {
int savedPausedState = RCT2_GLOBAL(RCT2_ADDRESS_GAME_PAUSED, uint8);
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_Z, uint16));
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride_are_all_possible_entrances_and_exits_built(ride)){
tool_cancel();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_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)
{
rct_ride *ride = GET_RIDE(_currentRideIndex);
rct_ride *ride = get_ride(_currentRideIndex);
// Set window title arguments
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;
rideA = GET_RIDE(*((uint8*)a));
rideB = GET_RIDE(*((uint8*)b));
rideA = get_ride(*((uint8*)a));
rideB = get_ride(*((uint8*)b));
return rideB->value - rideA->value;
}
@ -116,8 +116,8 @@ int ride_name_compare(const void *a, const void *b)
char rideAName[256], rideBName[256];
rct_ride *rideA, *rideB;
rideA = GET_RIDE(*((uint8*)a));
rideB = GET_RIDE(*((uint8*)b));
rideA = get_ride(*((uint8*)a));
rideB = get_ride(*((uint8*)b));
format_string(rideAName, rideA->name, &rideA->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;
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;
if (itemType != 255)
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)
break;
rct_ride *ride = GET_RIDE(window_new_campaign_rides[i]);
rct_ride *ride = get_ride(window_new_campaign_rides[i]);
gDropdownItemsFormat[i] = 1142;
gDropdownItemsArgs[i] = ((uint64)ride->name_arguments << 16ULL) | ride->name;
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_LABEL].image = STR_MARKETING_RIDE;
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;
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;
// 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
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)
return;
rideType = GET_RIDE_ENTRY(rideItem.entry_index);
rideType = get_ride_entry(rideItem.entry_index);
if(!gConfigInterface.select_by_track_type)
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);
// 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;
if (listItem->type != rideEntry->ride_type[0]) {
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)
{
rct_ride_type *rideEntry = GET_RIDE_ENTRY(item.entry_index);
rct_ride_type *rideEntry = get_ride_entry(item.entry_index);
// Ride name and description
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) {
uint32 typeId = RCT2_GLOBAL(RCT2_ADDRESS_NEXT_RESEARCH_ITEM, uint32);
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) ?
rideEntry->name :
((typeId >> 8) & 0xFF) + 2;
@ -388,7 +388,7 @@ void window_research_development_page_paint(rct_window *w, rct_drawpixelinfo *dp
int lastDevelopmentFormat;
if (typeId != 0xFFFFFFFF) {
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) ?
rideEntry->name :
((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))) {
int spriteIndex;
int rideType = GET_RIDE(w->number)->type;
int rideType = get_ride(w->number)->type;
switch (gRideClassifications[rideType]) {
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;
y = (widget->bottom - widget->top) - 12;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
uint8 trainLayout[16];
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)
{
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
@ -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)
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)
disabled_tabs |= (1 << WIDX_TAB_5); // 0x100
@ -1193,7 +1193,7 @@ rct_window *window_ride_open(int rideIndex)
w->max_width = 500;
w->max_height = 450;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
numSubTypes = 0;
rideEntryIndexPtr = get_ride_entry_indices_for_ride_type(ride->type);
for (; *rideEntryIndexPtr != 0xFF; rideEntryIndexPtr++) {
@ -1257,7 +1257,7 @@ rct_window *window_ride_open_station(int rideIndex, int stationIndex)
rct_ride *ride;
rct_window *w;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13))
return window_ride_main_open(rideIndex);
@ -1331,7 +1331,7 @@ rct_window *window_ride_open_vehicle(rct_vehicle *vehicle)
headVehicle = vehicle_get_head(vehicle);
headVehicleSpriteIndex = headVehicle->sprite_index;
rideIndex = headVehicle->ride;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
// Get view index
view = 1;
@ -1481,7 +1481,7 @@ static void window_ride_init_viewport(rct_window *w)
{
if (w->page != WINDOW_RIDE_PAGE_MAIN) return;
rct_ride* ride = GET_RIDE(w->number);
rct_ride* ride = get_ride(w->number);
int eax = w->viewport_focus_coordinates.var_480 - 1;
union{
@ -1615,7 +1615,7 @@ static void window_ride_rename(rct_window *w)
{
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;
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_OPEN_LIGHT:
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
switch (widgetIndex - WIDX_CLOSE_LIGHT) {
case 0:
@ -1697,7 +1697,7 @@ static void window_ride_main_resize(rct_window *w)
w->flags |= WF_RESIZABLE;
int minHeight = 180;
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);
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;
dropdownWidget = widget - 1;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
numItems = 1;
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;
int numItems, highlightedIndex, checkedIndex;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
numItems = 0;
gDropdownItemsFormat[numItems] = 1142;
@ -1883,7 +1883,7 @@ static void window_ride_main_dropdown(rct_window *w, int widgetIndex, int dropdo
case WIDX_VIEW_DROPDOWN:
if (dropdownIndex == -1) {
dropdownIndex = w->ride.view;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
dropdownIndex++;
if (dropdownIndex != 0 && dropdownIndex <= ride->num_vehicles && !(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
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)
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)
dropdownIndex++;
@ -1943,7 +1943,7 @@ static void window_ride_main_update(rct_window *w)
widget_invalidate(w, WIDX_TAB_1);
// Update status
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
if (!(ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAIN)) {
if (w->ride.view == 0)
return;
@ -2010,7 +2010,7 @@ static void window_ride_main_invalidate(rct_window *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));
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK))
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;
rct_string_id stringId;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
vehicleIndex = w->ride.view - 1;
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;
rct_string_id stringId;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
count = w->ride.view - ride->num_vehicles - 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)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
if (w->ride.view == 0)
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
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
stringId = STR_OVERALL_VIEW;
if (w->ride.view != 0) {
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;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
switch (widgetIndex) {
case WIDX_CLOSE:
@ -2328,7 +2328,7 @@ static void window_ride_vehicle_mousedown(int widgetIndex, rct_window *w, rct_wi
uint8 *rideEntryIndexPtr;
bool selectionShouldBeExpanded;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
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)) {
@ -2359,7 +2359,7 @@ static void window_ride_vehicle_mousedown(int widgetIndex, rct_window *w, rct_wi
for (uint8 *currentRideEntryIndex = rideEntryIndexPtr; *currentRideEntryIndex != 0xFF; 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
if ((currentRideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME)) && !(gConfigInterface.select_by_track_type || selectionShouldBeExpanded))
continue;
@ -2452,7 +2452,7 @@ static void window_ride_vehicle_dropdown(rct_window *w, int widgetIndex, int dro
if (dropdownIndex == -1)
return;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
switch (widgetIndex) {
@ -2502,7 +2502,7 @@ static void window_ride_vehicle_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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;
vehicle_colour vehicleColour;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
// 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)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TITLE, uint16) = 1362;
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)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
uint8 value = ride->operation_option;
//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);
@ -2770,7 +2770,7 @@ static void window_ride_mode_tweak_increase(rct_window *w)
*/
static void window_ride_mode_tweak_decrease(rct_window *w)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
uint8 value = ride->operation_option;
//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);
@ -2794,7 +2794,7 @@ static void window_ride_mode_dropdown(rct_window *w, rct_widget *widget)
int i, numAvailableModes;
dropdownWidget = widget - 1;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(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;
dropdownWidget = widget - 1;
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
for (i = 0; i < 5; i++) {
gDropdownItemsFormat[i] = 1142;
@ -2877,7 +2877,7 @@ static void window_ride_operating_mouseup(rct_window *w, int widgetIndex)
{
rct_ride *ride;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
switch (widgetIndex) {
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)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
uint8 parameter_check;
switch (widgetIndex) {
@ -2986,7 +2986,7 @@ static void window_ride_operating_dropdown(rct_window *w, int widgetIndex, int d
if (dropdownIndex == -1)
return;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
switch (widgetIndex) {
case WIDX_MODE_DROPDOWN:
@ -3013,7 +3013,7 @@ static void window_ride_operating_update(rct_window *w)
window_event_invalidate_call(w);
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) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_OPERATING;
window_invalidate(w);
@ -3041,7 +3041,7 @@ static void window_ride_operating_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
// Horizontal rule between mode settings and depart settings
gfx_fill_rect_inset(
@ -3273,7 +3273,7 @@ static void window_ride_locate_mechanic(rct_window *w)
rct_ride *ride;
rct_peep *mechanic;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
// First check if there is a mechanic assigned
mechanic = ride_get_assigned_mechanic(ride);
@ -3358,8 +3358,8 @@ static void window_ride_maintenance_mousedown(int widgetIndex, rct_window *w, rc
dropdownWidget = widget;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
switch (widgetIndex) {
case WIDX_INSPECTION_INTERVAL_DROPDOWN:
@ -3456,8 +3456,8 @@ static void window_ride_maintenance_dropdown(rct_window *w, int widgetIndex, int
if (dropdownIndex == -1)
return;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
switch (widgetIndex) {
case WIDX_INSPECTION_INTERVAL_DROPDOWN:
@ -3541,7 +3541,7 @@ static void window_ride_maintenance_update(rct_window *w)
window_event_invalidate_call(w);
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) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_MAINTENANCE;
window_invalidate(w);
@ -3566,7 +3566,7 @@ static void window_ride_maintenance_invalidate(rct_window *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 + 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_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
// Locate mechanic button image
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;
rct_string_id stringId;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
colourSchemeIndex = w->ride_colour;
dropdownWidget = widget - 1;
@ -4053,7 +4053,7 @@ static void window_ride_colour_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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;
track_colour trackColour;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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;
vehicle_colour vehicleColour;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
vehiclePreviewWidget = &window_ride_colour_widgets[WIDX_VEHICLE_PREVIEW];
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)
{
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
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;
dropdownWidget = widget - 1;
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
int numItems = 0;
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)
return;
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
musicStyle = window_ride_current_music_style_order[dropdownIndex];
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);
@ -4537,7 +4537,7 @@ static void window_ride_music_invalidate(rct_window *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 + 2, uint32) = ride->name_arguments;
@ -4598,7 +4598,7 @@ static void cancel_scenery_selection(){
* rct2: 0x006D27A3
*/
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){
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)
return;
rct_ride *ride = GET_RIDE(w->number);
rct_ride *ride = get_ride(w->number);
gDropdownItemsFormat[0] = STR_SAVE_TRACK_DESIGN_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);
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 + 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;
gfx_fill_rect_inset(dpi, x, y, w->x + 312, y + 1, w->colours[1], 0x20);
} else {
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
x = w->x + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].left + 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);
if (measurement != NULL && (measurement->flags & RIDE_MEASUREMENT_FLAG_RUNNING)) {
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;
} else {
*stringId = message;
@ -5222,7 +5222,7 @@ static void window_ride_graphs_invalidate(rct_window *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 + 2, uint32) = ride->name_arguments;
@ -5406,8 +5406,8 @@ static void window_ride_income_toggle_primary_price(rct_window *w)
uint32 newFlags, shop_item;
money16 price;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
if (ride->type == RIDE_TYPE_TOILETS) {
shop_item = 0x1F;
@ -5453,8 +5453,8 @@ static void window_ride_income_toggle_secondary_price(rct_window *w)
uint32 newFlags, shop_item;
money16 price;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
shop_item = ride_type->shop_item_secondary;
if (shop_item == 0xFF)
@ -5494,8 +5494,8 @@ static void window_ride_income_increase_primary_price(rct_window *w)
rct_ride *ride;
rct_ride_type *ride_type;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
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) {
@ -5519,8 +5519,8 @@ static void window_ride_income_decrease_primary_price(rct_window *w)
rct_ride *ride;
rct_ride_type *ride_type;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
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) {
@ -5544,8 +5544,8 @@ static void window_ride_income_increase_secondary_price(rct_window *w)
rct_ride *ride;
rct_ride_type *ride_type;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
money16 price = ride->price_secondary;
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_type *ride_type;
ride = GET_RIDE(w->number);
ride_type = gRideTypeList[ride->subtype];
ride = get_ride(w->number);
ride_type = get_ride_entry(ride->subtype);
money16 price = ride->price_secondary;
if (price > MONEY(0, 00))
@ -5647,7 +5647,7 @@ static void window_ride_income_update(rct_window *w)
window_event_invalidate_call(w);
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) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_INCOME;
window_invalidate(w);
@ -5675,7 +5675,7 @@ static void window_ride_income_invalidate(rct_window *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 + 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_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number);
ride = get_ride(w->number);
rideEntry = ride_get_entry(ride);
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);
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) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_CUSTOMER;
window_invalidate(w);
@ -5942,7 +5942,7 @@ static void window_ride_customer_invalidate(rct_window *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 + 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_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;
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);
rct_window *w;
rct_ride* ride = GET_RIDE(rideIndex);
rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE)
return window_maze_construction_open();
@ -583,7 +583,7 @@ static void window_ride_construction_close(rct_window *w)
uint8 rideIndex = _currentRideIndex;
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) {
ride->status = RIDE_STATUS_OPEN;
}
@ -648,7 +648,7 @@ static void window_ride_construction_resize(rct_window *w)
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);
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)
{
rct_ride *ride = GET_RIDE(_currentRideIndex);
rct_ride *ride = get_ride(_currentRideIndex);
int rideType;
window_ride_construction_update_enabled_track_pieces();
@ -2064,7 +2064,7 @@ static void window_ride_construction_invalidate(rct_window *w)
rct_ride *ride;
rct_string_id stringId;
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
stringId = STR_RIDE_CONSTRUCTION_SPECIAL;
if (_currentTrackCurve >= 256) {
@ -2140,7 +2140,7 @@ static void window_ride_construction_draw_track_piece(
const rct_preview_track *trackBlock;
rct_ride *ride;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
trackBlock = get_track_def_from_ride(ride, trackType);
while ((trackBlock + 1)->index != 0xFF)
@ -2240,7 +2240,7 @@ static void sub_6CBCE2(
RCT2_GLOBAL(0x00EE7880, uint32) = 0x00F1A4CC;
painter_setup();
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
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()
{
rct_ride *ride = GET_RIDE(_currentRideIndex);
rct_ride *ride = get_ride(_currentRideIndex);
rct_ride_type *rideEntry = ride_get_entry(ride);
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;
sub_6C96C0();
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
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);
if (result == MONEY32_UNDEFINED)
@ -2594,7 +2594,7 @@ static void window_ride_construction_update_map_selection()
break;
}
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
window_ride_construction_select_map_tiles(ride, trackType, trackDirection, x, y);
map_invalidate_map_selection_tiles();
}
@ -2609,7 +2609,7 @@ static void window_ride_construction_update_possible_ride_configurations()
int trackType;
int edx, edi;
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
RCT2_GLOBAL(0x00F440D3, uint8) = 0;
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)
{
uint8 rideIndex = _currentRideIndex;
rct_ride *ride = GET_RIDE(rideIndex);
rct_ride *ride = get_ride(rideIndex);
int rideType = ride_get_alternative_type(ride);
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];
rct_string_id trackPieceStringId = RideConfigurationStringIds[trackPiece];
if (trackPieceStringId == STR_RAPIDS) {
rct_ride *ride = GET_RIDE(_currentRideIndex);
rct_ride *ride = get_ride(_currentRideIndex);
if (ride->type == RIDE_TYPE_CAR_RIDE)
trackPieceStringId = STR_LOG_BUMPS;
}
@ -3314,7 +3314,7 @@ void ride_construction_toolupdate_construct(int screenX, int screenY)
return;
}
_currentTrackPieceType = trackType;
ride = GET_RIDE(_currentRideIndex);
ride = get_ride(_currentRideIndex);
// Re-using this other code, very slight difference from original
// - 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();
rct_ride *ride = GET_RIDE(_currentRideIndex);
rct_ride *ride = get_ride(_currentRideIndex);
if (_trackPlaceZ == 0) {
const rct_preview_track *trackBlock = get_track_def_from_ride(ride, _currentTrackPieceType);
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)
);
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)) {
tool_cancel();
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
ride = &g_ride_list[w->list_item_positions[i]];
ride = get_ride(w->list_item_positions[i]);
// Ride name
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;
format_string_to_upper(bufferA, ride->name, &ride->name_arguments);
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);
if (strcmp(bufferA, bufferB) >= 0)
break;
@ -623,7 +623,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_POPULARITY:
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)
break;
@ -632,7 +632,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_SATISFACTION:
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)
break;
@ -641,7 +641,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_PROFIT:
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)
break;
@ -650,7 +650,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_QUEUE_LENGTH:
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))
break;
@ -659,7 +659,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_QUEUE_TIME:
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))
break;
@ -668,7 +668,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_RELIABILITY:
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)
break;
@ -677,7 +677,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_DOWN_TIME:
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)
break;
@ -686,7 +686,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break;
case INFORMATION_TYPE_GUESTS_FAVOURITE:
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)
break;

4
src/windows/sign.c
View File

@ -257,7 +257,7 @@ static void window_sign_mouseup(rct_window *w, int widgetIndex)
break;
case WIDX_SIGN_TEXT:
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;
string_id = ride->name;
}
@ -521,7 +521,7 @@ static void window_sign_small_mouseup(rct_window *w, int widgetIndex)
break;
case WIDX_SIGN_TEXT:
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;
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(
buffer,
"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;
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);
entry = GET_RIDE_ENTRY(_window_track_list_item.entry_index);
entry = get_ride_entry(_window_track_list_item.entry_index);
stringId = entry->name;
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;
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))
continue;

8
src/world/footpath.c
View File

@ -1122,7 +1122,7 @@ static void loc_6A6D7E(
break;
case MAP_ELEMENT_TYPE_TRACK:
if (z == mapElement->base_height) {
rct_ride *ride = GET_RIDE(mapElement->properties.track.ride_index);
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
continue;
}
@ -1213,7 +1213,7 @@ static void loc_6A6C85(
}
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) {
rct_ride *ride = GET_RIDE(mapElement->properties.track.ride_index);
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
return;
}
@ -1406,7 +1406,7 @@ void sub_6A759F()
for (esi = (uint8*)0x00F3EFF8; esi < RCT2_GLOBAL(0x00F3EFF4, uint8*); esi++) {
rideIndex = *esi;
ride = GET_RIDE(rideIndex);
ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
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) {
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))
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)
continue;
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)
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;
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 typeAndSequence = (trackType << 4) | sequence;
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 (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;
}
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) {
return false;
}
@ -3796,7 +3796,7 @@ static void map_obstruction_set_error_text(rct_map_element *mapElement)
errorStringId = STR_FOOTPATH_IN_THE_WAY;
break;
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;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
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)
continue;
ride = GET_RIDE(mapElement->properties.entrance.ride_index);
ride = get_ride(mapElement->properties.entrance.ride_index);
entranceDefinition = &RideEntranceDefinitions[ride->entrance_style];
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
result = 0;
for (i = 0; i < 255; i++) {
ride = &g_ride_list[i];
ride = get_ride(i);
result += calculate_ride_value(ride);
}