From cba820b7a29385c379ea81a377189ee6b2fc5cd2 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Wed, 3 Feb 2016 21:31:30 +0100 Subject: [PATCH 01/11] Decompile function --- src/peep/peep.c | 796 ++++++++++++++++++++++++++++++++++++++++++++- src/ride/ride.c | 3 + src/world/sprite.c | 8 +- 3 files changed, 803 insertions(+), 4 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 74bbdc424b..494bd62b29 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -91,6 +91,33 @@ static void peep_give_real_name(rct_peep *peep); static int guest_surface_path_finding(rct_peep* peep); static void peep_read_map(rct_peep *peep); static bool peep_heading_for_ride_or_park_exit(rct_peep *peep); +static void loc_6C0EEC(int steps, rct_peep *peep, rct_ride *ride) ; +static void loc_6C0F09(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C0FAA(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C0FD3(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C10A5(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C11CC(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C11F5(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C13B4(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C13CE(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C13F8(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C14E5(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C15EF(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C100D(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C107B(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C121F(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C133F(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C157E(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1114(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1239(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl); +static void loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl); +static void loc_6C1368(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1474(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1504(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1559(int steps, rct_peep *peep, rct_ride *ride); +static void loc_6C1653(int steps, rct_peep *peep, rct_ride *ride) ; +static void sub_6B7588(int rideIndex); const char *gPeepEasterEggNames[] = { "MICHAEL SCHUMACHER", @@ -3421,7 +3448,774 @@ static void peep_update_fixing(int steps, rct_peep* peep){ return; } - RCT2_CALLPROC_X(RCT2_ADDRESS(0x006C0EB0, uint32)[peep->sub_state], steps, 0, 0, 0, (int)peep, (int)ride, 0); + switch (peep->sub_state) { + case 0: + loc_6C0EEC(steps, peep, ride); + break; + + case 1: + loc_6C0FAA(steps, peep, ride); + break; + + case 2: + case 3: + case 4: + case 5: + loc_6C100D(steps, peep, ride); + break; + + case 6: + loc_6C10A5(steps, peep, ride); + break; + + case 7: + loc_6C11CC(steps, peep, ride); + break; + + case 8: + loc_6C121F(steps, peep, ride); + break; + + case 9: + loc_6C133F(steps, peep, ride); + break; + + case 10: + loc_6C13B4(steps, peep, ride); + break; + + case 11: + loc_6C13F8(steps, peep, ride); + break; + + case 12: + loc_6C14E5(steps, peep, ride); + break; + + case 13: + loc_6C1559(steps, peep, ride); + break; + + case 14: + loc_6C15EF(steps, peep, ride); + break; + + default: + log_error("Invalid substate"); + RCT2_CALLPROC_X(RCT2_ADDRESS(0x006C0EB0, uint32)[peep->sub_state], steps, 0, 0, 0, (int) peep, (int) ride, 0); + } + +} + +void loc_6C0EEC(int steps, rct_peep *peep, rct_ride *ride) { + // eax: steps + // esi: peep + // edi: ride + + ride->mechanic_status = 3; + ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE; + + loc_6C1653(steps, peep, ride); +} + +void loc_6C0F09(int steps, rct_peep *peep, rct_ride *ride) { + uint32 ebx = ride->broken_vehicle; + uint16 bp = ride->vehicles[ebx]; + + if (bp == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + + rct_vehicle *vehicle = GET_VEHICLE(bp); + sint8 ah = ride->broken_car; + + // loc_6C0F3E: + while (true) { + ah--; + if (ah < 0) { + break; + } + + vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); + } + + // loc_6C0F51: + while (true) { + if (vehicle->is_child == 0) { + break; + } + + uint8 trackType = vehicle->track_type >> 2; + if (trackType == TRACK_ELEM_END_STATION) { + break; + } + + if (trackType == TRACK_ELEM_BEGIN_STATION) { + break; + } + + if (trackType == TRACK_ELEM_MIDDLE_STATION) { + break; + } + + vehicle = GET_VEHICLE(vehicle->prev_vehicle_on_ride); + } + + // loc_6C0F7A: + uint32 peepDirection = peep->var_78; + + sint16 ax = word_981D6C[peepDirection].x; + sint16 cx = word_981D6C[peepDirection].y; + + ax *= -12; + cx *= -12; + + ax += vehicle->x; + cx += vehicle->y; + + peep->destination_x = ax; + peep->destination_y = cx; + peep->destination_tolerence = 2; + + loc_6C0FAA(steps, peep, ride); +} + +static void loc_6C0FAA(int steps, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_xy_distance; + + invalidate_sprite_2((rct_sprite *) peep); + if (peep_update_action(&x, &y, &tmp_xy_distance, peep)) { + sprite_move(x, y, peep->z, (rct_sprite *) peep); + invalidate_sprite_2((rct_sprite *) peep); + return; + } + + loc_6C1653(steps, peep, ride); +} + +void loc_6C0FD3(int steps, rct_peep *peep, rct_ride *ride) { + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX; + if (scenario_rand() & 0x100000) { + peep->action = PEEP_ACTION_STAFF_FIX_2; + } + + // loc_6C0FFB: + peep->action_sprite_image_offset = 0; + peep->action_frame = 0; + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C100D(steps, peep, ride); +} + +static void loc_6C100D(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_distance; + + if (peep->action == 0xFF) { + loc_6C1653(steps, peep, ride); + return; + } + + peep_update_action(&tmp_x, &tmp_y, &tmp_distance, peep); + + uint8 al = peep->action; + sint8 ah = 0x25; + if (al != 0x0F) { + ah = 0x50; + } + + // loc_6C1027 + if (peep->action_frame != ah) { + return; + } + + uint32 ebx = ride->broken_vehicle; + uint16 bp = ride->vehicles[ebx]; + + if (bp == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + + rct_sprite *sprite = &g_sprite_list[bp]; + ah = ride->broken_car; + + // loc_6C1061 + do { + ah--; + if (ah < 0) { + sprite->vehicle.update_flags = 0xFEFF; + return;; + } + + sprite = &g_sprite_list[sprite->vehicle.next_vehicle_on_train]; + } while (true); +} + +void loc_6C107B(int steps, rct_peep *peep, rct_ride *ride) { + peep->sprite_direction = peep->var_78 << 3; + peep->action = 18; + peep->action_sprite_image_offset = 0; + peep->action_frame = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C10A5(steps, peep, ride); +} + +static void loc_6C10A5(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_distance; + + if (peep->action == 0xFF) { + loc_6C1653(steps, peep, ride); + return; + } + + peep_update_action(&tmp_x, &tmp_y, &tmp_distance, peep); + if (peep->action_frame != 0x65) { + return; + } + + // loc_6C10C5 + uint32 ebx = ride->broken_vehicle; + uint16 bp = ride->vehicles[ebx]; + if (bp == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + + rct_sprite *sprite = &g_sprite_list[bp]; + sint8 ah = ride->broken_car; + + // loc_6C10FA: + while (true) { + ah--; + if (ah < 0) { + // loc_6C110D: + sprite->vehicle.update_flags &= 0xFDFF; + return; + } + + sprite = &g_sprite_list[sprite->vehicle.next_vehicle_on_train]; + } +} + +void loc_6C1114(int steps, rct_peep *peep, rct_ride *ride) { + + if (ride_type_has_flag(ride->type, 0x8008)) { + loc_6C1653(steps, peep, ride); + return; + } + + uint16 ax = ride->station_starts[peep->current_ride_station]; + if (ax == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + + + uint8 dl = ride->station_heights[peep->current_ride_station]; + + + uint16 cx = 0; + uint8 cl = ax >> 8; + uint8 al = ax & 0xFF; + + ax = al << 5; + cx = cl << 5; + + // loc_6C1175: + rct_map_element *mapElement = map_get_track_element_at(ax, cx, dl); + if (mapElement == NULL) { + log_error("Couldn't find map_element"); + return; + } + + // loc_6C118A: + int ebx = map_element_get_direction(mapElement); + ax += 10; + cx += 10; + uint16 dx = RCT2_ADDRESS(0x992A3C, uint16)[ebx * 2]; + ax += dx; + if (dx == 0) { + ax = peep->destination_x; + } + + // loc_6C11AC: + dx = RCT2_ADDRESS(0x992A3E, uint16)[ebx * 2]; + cx += dx; + if (dx == 0) { + cx = peep->destination_y; + } + + // loc_6C11C0: + peep->destination_x = ax; + peep->destination_y = cx; + peep->destination_tolerence = 2; + + loc_6C11CC(steps, peep, ride); +} + +static void loc_6C11CC(int steps, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_distance; + + invalidate_sprite_2((rct_sprite *) peep); + int out = peep_update_action(&x, &y, &tmp_distance, peep); + if (out == 0) { + loc_6C1653(steps, peep, ride); + return; + } + + sprite_move(x, y, peep->z, (rct_sprite *) peep); + invalidate_sprite_2((rct_sprite *) peep); +} + +void loc_6C11F5(int steps, rct_peep *peep, rct_ride *ride) { + // eax: steps + // esi: peep + // edi: ride + + uint8 direction = peep->var_78 << 3; + peep->sprite_direction = direction; + peep->action = PEEP_ACTION_STAFF_CHECKBOARD; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C121F(steps, peep, ride); +} + +static void loc_6C121F(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_xy_distance; + + if (peep->action == 0xFF) { + loc_6C1653(steps, peep, ride); + return; + } + + peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); +} + +void loc_6C1239(int steps, rct_peep *peep, rct_ride *ride) { + // eax: steps + // esi: peep + // edi: ride + + if (!ride_type_has_flag(ride->type, 0x8008)) { + loc_6C1653(steps, peep, ride); + return; + } + + uint16 ax = ride->station_starts[peep->current_ride_station]; + + if (ax == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + + uint8 dl = ride->station_heights[peep->current_ride_station]; + uint8 dh = peep->current_ride; + + uint16 cx = ax >> 8; + ax &= 0x00FF; + + ax = ax << 5; + cx = cx << 5; + + loc_6C1288(steps, peep, ride, ax, cx, dh, dl); +} + +void static loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl) { + + uint32 ebp = ((cx << 8) | ax) >> 3; + rct_map_element *ebp_tile = TILE_MAP_ELEMENT_POINTER(ebp / 8); + + do { + // loc_6C129D: + + if (map_element_get_type(ebp_tile) != 8) { + continue; + } + if (ebp_tile->properties.track.ride_index != dh) { + continue; + } + + if (ebp_tile->base_height != dl) { + continue; + } + + uint8 trackType = ebp_tile->properties.track.type; + if (trackType == 2 || trackType == 3 || trackType == 1) { + // loc_6C12CF: + + uint8 direction = ebp_tile->type & 3; + RCT2_GLOBAL(0xF43914, uint32) = direction; + + ax -= TileDirectionDelta[direction].x; + cx -= TileDirectionDelta[direction].y; + loc_6C1288(steps, peep, ride, ax, cx, dh, dl); + return;; + } + + // loc_6C12C4: + } while (!map_element_is_last_for_tile(ebp_tile++)); + + // loc_6C12ED: + uint8 direction = RCT2_GLOBAL(0xF43914, uint32); + ax += TileDirectionDelta[direction].x; + cx += TileDirectionDelta[direction].y; + + ax += 0x10; + cx += 0x10; + + sint16 delta_2_x = RCT2_ADDRESS(0x992A3C, uint16)[direction * 2]; // TODO: Is this an rct_xy16? + ax -= delta_2_x; + if (delta_2_x == 0) { + ax = peep->destination_x; + } + + sint16 delta_2_y = RCT2_ADDRESS(0x992A3E, uint16)[direction * 2];// TODO: Is this an rct_xy16? + cx -= delta_2_y; + if (delta_2_y == 0) { + cx = peep->destination_y; + } + + peep->destination_x = ax; + peep->destination_y = cx; + peep->destination_tolerence = 2; + + loc_6C133F(steps, peep, ride); +} + +static void loc_6C133F(int steps, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_xy_distance; + + invalidate_sprite_2((rct_sprite *) peep); + + int out = peep_update_action(&x, &y, &tmp_xy_distance, peep); + if (out == 0) { + loc_6C1653(steps, peep, ride); + return; + } + + sprite_move(x, y, peep->z, (rct_sprite *) peep); + invalidate_sprite_2((rct_sprite *) peep); +} + +void loc_6C1368(int steps, rct_peep *peep, rct_ride *ride) { + if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 & RIDE_TYPE_FLAG_15)) { + loc_6C1653(steps, peep, ride); + return;; + } + + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C13B4(steps, peep, ride); +} + +static void loc_6C13B4(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_xy_distance; + + if (peep->action == 0xFF) { + loc_6C1653(steps, peep, ride); + return; + } + + peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); +} + +void loc_6C13CE(int steps, rct_peep *peep, rct_ride *ride) { + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX_GROUND; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C13F8(steps, peep, ride); +} + +static void loc_6C13F8(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_xy_distance; + + if (peep->action == 0xFF) { + loc_6C1653(steps, peep, ride); + return; + } + + peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); + if (peep->action_frame == 0x28) { + ride->mechanic_status = 4; + ride->window_invalidate_flags |= 0x20; + } + + // loc_6C142F + if (peep->action_frame == 0x13 || + peep->action_frame == 0x19 || + peep->action_frame == 0x1F || + peep->action_frame == 0x25 || + peep->action_frame == 0x2B) { + // loc_6C144E: + audio_play_sound_at_location(SOUND_MECHANIC_FIX, peep->x, peep->y, peep->z); + } +} + +void loc_6C1474(int steps, rct_peep *peep, rct_ride *ride) { + uint8 ebx = peep->current_ride_station; + + uint16 ax = ride->exits[ebx]; + if (ax == 0xFFFF) { + ax = ride->entrances[ebx]; + + if (ax == 0xFFFF) { + loc_6C1653(steps, peep, ride); + return; + } + } + + // loc_6C14A2: + + uint16 cx = ax >> 8; + ax &= 0x00FF; + + ax = ax << 5; + cx = cx << 5; + + ax += 16; + cx += 10; + + rct_xy16 direction = word_981D6C[peep->var_78]; + + + ax += direction.x * 20; + cx += direction.y * 20; + + peep->destination_x = ax; + peep->destination_y = cx; + peep->destination_tolerence = 2; + + loc_6C14E5(steps, peep, ride); +} + +static void loc_6C14E5(int steps, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_xy_distance; + + invalidate_sprite_2((rct_sprite *) peep); + if (peep_update_action(&x, &y, &tmp_xy_distance, peep) == 0) { + loc_6C1653(steps, peep, ride); + } else { + sprite_move(x, y, peep->z, (rct_sprite *) peep); + invalidate_sprite_2((rct_sprite *) peep); + } +} + +void loc_6C1504(int steps, rct_peep *peep, rct_ride *ride) { + if (peep->state == PEEP_STATE_INSPECTING) { + sub_6B7588(peep, peep->current_ride); + + peep->staff_rides_inspected++; + peep->window_invalidate_flags |= 10; + loc_6C1653(steps, peep, ride); + return; + } + + // loc_6C1524: + peep->staff_rides_fixed++; + peep->window_invalidate_flags |= 10; + + peep->sprite_direction = peep->var_78 << 3; + peep->action = PEEP_ACTION_STAFF_ANSWER_CALL_2; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + + loc_6C1559(steps, peep, ride); +} + +static void loc_6C1559(int steps, rct_peep *peep, rct_ride *ride) { + sint16 tmp_x, tmp_y, tmp_xy_distance; + + if (peep->action != 0xFF) { + peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); + return; + } + + // loc_6C156F: + ride_fix_breakdown(peep->current_ride, steps); // TODO: What should be the reliabilityIncreaseFactor? + + loc_6C1653(steps, peep, ride); +} + +void loc_6C157E(int steps, rct_peep *peep, rct_ride *ride) { + uint32 ebx = peep->current_ride_station; + + uint16 ax = ride->exits[ebx]; + if (ax == 0xFFFF) { + ax = ride->entrances[ebx]; + + if (ax == 0xFFFF) { + // loc_6C1644: + peep_decrement_num_riders(peep); + peep->state = 0; + peep_window_state_update(peep); + return; + } + } + + // loc_6C15AC + + uint16 cx = ax >> 8; + ax = ax & 0x00FF; + ax = ax << 5; + cx = cx << 5; + + ebx = peep->var_78; + + ax += 16; + cx += 16; + + rct_xy16 ebx_direction = word_981D6C[ebx]; + ax -= ebx_direction.x * 19; + cx -= ebx_direction.y * 19; + + peep->destination_x = ax; + peep->destination_y = cx; + peep->destination_tolerence = 2; + + loc_6C15EF(steps, peep, ride); +} + +static void loc_6C15EF(int steps, rct_peep *peep, rct_ride *ride) { + sint16 x, y, xy_distance; + + invalidate_sprite_2((rct_sprite *) peep); + int out = peep_update_action(&x, &y, &xy_distance, peep); + if (out == 0) { + // loc_6C1644: + peep_decrement_num_riders(peep); + peep->state = 0; + peep_window_state_update(peep); + return; + } + + uint16 z = ride->station_heights[peep->current_ride_station]; + z = z << 3; + + if (xy_distance >= 16) { + z += RCT2_ADDRESS(0x0097D21C, uint8)[ride->type * 8]; + } + + // loc_6C1639: + sprite_move(x, y, z, (rct_sprite *) peep); + invalidate_sprite_2((rct_sprite *) peep);; +} + +void loc_6C1653(int steps, rct_peep *peep, rct_ride *ride) { + // eax: steps + // esi: peep + // edi: ride + + int edx = peep->sub_state; + uint32 ebp = RCT2_ADDRESS(0x992A18, uint32)[8]; + + if (peep->state != PEEP_STATE_INSPECTING) { + ebp = ride->breakdown_reason_pending; + ebp = RCT2_ADDRESS(0x992A18, uint32)[ride->breakdown_reason_pending]; + } + + // loc_6C167B + do { + edx++; + } while ((ebp & (1 << edx)) == 0); + + peep->sub_state = edx & 0xFF; + + // off_6C168C + switch (edx) { + case 0: + loc_6C0EEC(steps, peep, ride); + break; + + case 1: + loc_6C0F09(steps, peep, ride); + break; + + case 2: + case 3: + case 4: + case 5: + loc_6C0FD3(steps, peep, ride); + break; + + case 6: + loc_6C107B(steps, peep, ride); + break; + + case 7: + loc_6C1114(steps, peep, ride); + break; + + case 8: + loc_6C11F5(steps, peep, ride); + break; + + case 9: + loc_6C1239(steps, peep, ride); + break; + + case 10: + loc_6C1368(steps, peep, ride); + break; + + case 11: + loc_6C13CE(steps, peep, ride); + break; + + case 12: + loc_6C1474(steps, peep, ride); + break; + + case 13: + loc_6C1504(steps, peep, ride); + break; + + case 14: + loc_6C157E(steps, peep, ride); + break; + + default: + RCT2_CALLPROC_X(RCT2_ADDRESS(0x006C0EB0, uint32)[peep->sub_state], steps, 0, 0, 0, (int) peep, (int) ride, 0); + } +} + +/** + * rct2: 0x6B7588 + */ +static void sub_6B7588(int rideIndex) { + rct_ride *ride = get_ride(rideIndex); + ride->lifecycle_flags &= 0xFFFFFEFF; + + ride->reliability += ((100 - ride->reliability) >> 2) * (scenario_rand() & 0xFF); + ride->last_inspection = 0; + ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST; } /** diff --git a/src/ride/ride.c b/src/ride/ride.c index 439e45b275..00aa7d279e 100644 --- a/src/ride/ride.c +++ b/src/ride/ride.c @@ -7104,6 +7104,9 @@ void invalidate_test_results(int rideIndex) /** * * rct2: 0x006B7481 + * + * @param rideIndex (dl) + * @param reliabilityIncreaseFactor (ax) */ void ride_fix_breakdown(int rideIndex, int reliabilityIncreaseFactor) { diff --git a/src/world/sprite.c b/src/world/sprite.c index cfadb6ba3c..e454cff11c 100644 --- a/src/world/sprite.c +++ b/src/world/sprite.c @@ -74,9 +74,11 @@ void invalidate_sprite_1(rct_sprite *sprite) } /** -* Invalidate sprite if not at furthest zoom. -* rct2: 0x006EC473 -*/ + * Invalidate sprite if not at furthest zoom. + * rct2: 0x006EC473 + * + * @param sprite (esi) + */ void invalidate_sprite_2(rct_sprite *sprite) { invalidate_sprite_max_zoom(sprite, 2); From 6c601170f08fbdc156cb2deaa81552d15ac69368 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Thu, 4 Feb 2016 10:14:27 +0100 Subject: [PATCH 02/11] Add documentation to functions --- src/peep/peep.c | 5 +++++ src/scenario.c | 2 ++ src/world/sprite.c | 8 +++++--- 3 files changed, 12 insertions(+), 3 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 494bd62b29..9643b2566e 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -1002,6 +1002,11 @@ void peep_check_cant_find_exit(rct_peep* peep){ * start an action. Returns 1 if the correct destination * has not yet been reached. xy_distance is how close the * peep is to the target. + * + * @param x (ax) + * @param y (cx) + * @param distance (bp) + * @param peep (esi) */ int peep_update_action(sint16* x, sint16* y, sint16* xy_distance, rct_peep* peep){ RCT2_GLOBAL(0xF1AEF0, uint8) = peep->action_sprite_image_offset; diff --git a/src/scenario.c b/src/scenario.c index 725775f508..b33c6f6659 100644 --- a/src/scenario.c +++ b/src/scenario.c @@ -688,6 +688,8 @@ static int scenario_create_ducks() /** * * rct2: 0x006E37D2 + * + * @return eax */ unsigned int scenario_rand() { diff --git a/src/world/sprite.c b/src/world/sprite.c index e454cff11c..60ce0a7caf 100644 --- a/src/world/sprite.c +++ b/src/world/sprite.c @@ -417,9 +417,11 @@ void sprite_misc_update_all() /** * Moves a sprite to a new location. * rct2: 0x0069E9D3 - * ax: x - * cx: y - * dx: z + * + * @param x (ax) + * @param y (cx) + * @param z (dx) + * @param sprite (esi) */ void sprite_move(sint16 x, sint16 y, sint16 z, rct_sprite* sprite){ if (x < 0 || y < 0 || x > 0x1FFF || y > 0x1FFF) From 65e74b92ae9e7dddc6a3f31b5b8df897ceac4ff5 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Thu, 4 Feb 2016 20:41:03 +0100 Subject: [PATCH 03/11] Clean up function --- src/peep/peep.c | 999 ++++++++++++++++++++---------------------------- 1 file changed, 412 insertions(+), 587 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 9643b2566e..391c42717c 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -41,6 +41,7 @@ #include "../cheats.h" #include "peep.h" #include "staff.h" +#include "../ride/vehicle.h" enum { PATH_SEARCH_DEAD_END, @@ -91,32 +92,23 @@ static void peep_give_real_name(rct_peep *peep); static int guest_surface_path_finding(rct_peep* peep); static void peep_read_map(rct_peep *peep); static bool peep_heading_for_ride_or_park_exit(rct_peep *peep); -static void loc_6C0EEC(int steps, rct_peep *peep, rct_ride *ride) ; -static void loc_6C0F09(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C0FAA(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C0FD3(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C10A5(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C11CC(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C11F5(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C13B4(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C13CE(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C13F8(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C14E5(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C15EF(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C100D(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C107B(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C121F(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C133F(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C157E(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1114(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1239(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl); -static void loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl); -static void loc_6C1368(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1474(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1504(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1559(int steps, rct_peep *peep, rct_ride *ride); -static void loc_6C1653(int steps, rct_peep *peep, rct_ride *ride) ; +static bool peep_update_fixing_sub_state_0(rct_ride *ride); +static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep); + +static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride); + +static bool loc_6C1288(rct_peep *peep, rct_ride *ride, uint16 stationX, uint16 stationY, uint8 currentRide, uint8 stationZ); + +static bool peep_update_fixing_sub_state_9_a(rct_peep *peep); +static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_13(bool firstRun, int steps, rct_peep *peep, rct_ride *ride); +static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_ride *ride); static void sub_6B7588(int rideIndex); const char *gPeepEasterEggNames[] = { @@ -3453,392 +3445,335 @@ static void peep_update_fixing(int steps, rct_peep* peep){ return; } - switch (peep->sub_state) { - case 0: - loc_6C0EEC(steps, peep, ride); - break; + bool do_6c1653 = true; + bool firstRun = true; - case 1: - loc_6C0FAA(steps, peep, ride); - break; + while (do_6c1653) { + switch (peep->sub_state) { + case 0: + do_6c1653 = peep_update_fixing_sub_state_0(ride); + break; - case 2: - case 3: - case 4: - case 5: - loc_6C100D(steps, peep, ride); - break; + case 1: + do_6c1653 = peep_update_fixing_sub_state_1(firstRun, peep, ride); + break; - case 6: - loc_6C10A5(steps, peep, ride); - break; + case 2: + case 3: + case 4: + case 5: + do_6c1653 = peep_update_fixing_sub_state_2345(firstRun, peep, ride); + break; - case 7: - loc_6C11CC(steps, peep, ride); - break; + case 6: + do_6c1653 = peep_update_fixing_sub_state_6(firstRun, peep, ride); + break; - case 8: - loc_6C121F(steps, peep, ride); - break; + case 7: + do_6c1653 = peep_update_fixing_sub_state_7(firstRun, peep, ride); + break; - case 9: - loc_6C133F(steps, peep, ride); - break; + case 8: + do_6c1653 = peep_update_fixing_sub_state_8(firstRun, peep); + break; - case 10: - loc_6C13B4(steps, peep, ride); - break; + case 9: + do_6c1653 = peep_update_fixing_sub_state_9(firstRun, peep, ride); + break; - case 11: - loc_6C13F8(steps, peep, ride); - break; + case 10: + do_6c1653 = peep_update_fixing_sub_state_10(firstRun, peep, ride); + break; - case 12: - loc_6C14E5(steps, peep, ride); - break; + case 11: + do_6c1653 = peep_update_fixing_sub_state_11(firstRun, peep, ride); + break; - case 13: - loc_6C1559(steps, peep, ride); - break; + case 12: + do_6c1653 = peep_update_fixing_sub_state_12(firstRun, peep, ride); + break; - case 14: - loc_6C15EF(steps, peep, ride); - break; + case 13: + do_6c1653 = peep_update_fixing_sub_state_13(firstRun, steps, peep, ride); + break; - default: - log_error("Invalid substate"); - RCT2_CALLPROC_X(RCT2_ADDRESS(0x006C0EB0, uint32)[peep->sub_state], steps, 0, 0, 0, (int) peep, (int) ride, 0); + case 14: + do_6c1653 = peep_update_fixing_sub_state_14(firstRun, peep, ride); + break; + + default: + log_error("Invalid substate"); + do_6c1653 = false; + } + + firstRun = false; + + if (!do_6c1653) { + break; + } + + int edx = peep->sub_state; + uint32 ebp = RCT2_ADDRESS(0x992A18, uint32)[8]; + + if (peep->state != PEEP_STATE_INSPECTING) { + ebp = RCT2_ADDRESS(0x992A18, uint32)[ride->breakdown_reason_pending]; + } + + // loc_6C167B + do { + edx++; + } while ((ebp & (1 << edx)) == 0); + + peep->sub_state = edx & 0xFF; } - } -void loc_6C0EEC(int steps, rct_peep *peep, rct_ride *ride) { - // eax: steps - // esi: peep - // edi: ride - - ride->mechanic_status = 3; +static bool peep_update_fixing_sub_state_0(rct_ride *ride) { + ride->mechanic_status = RIDE_MECHANIC_STATUS_FIXING; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE; - loc_6C1653(steps, peep, ride); + return true; } -void loc_6C0F09(int steps, rct_peep *peep, rct_ride *ride) { - uint32 ebx = ride->broken_vehicle; - uint16 bp = ride->vehicles[ebx]; - - if (bp == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; - } - - rct_vehicle *vehicle = GET_VEHICLE(bp); - sint8 ah = ride->broken_car; - - // loc_6C0F3E: - while (true) { - ah--; - if (ah < 0) { - break; - } - - vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); - } - - // loc_6C0F51: - while (true) { - if (vehicle->is_child == 0) { - break; - } - - uint8 trackType = vehicle->track_type >> 2; - if (trackType == TRACK_ELEM_END_STATION) { - break; - } - - if (trackType == TRACK_ELEM_BEGIN_STATION) { - break; - } - - if (trackType == TRACK_ELEM_MIDDLE_STATION) { - break; - } - - vehicle = GET_VEHICLE(vehicle->prev_vehicle_on_ride); - } - - // loc_6C0F7A: - uint32 peepDirection = peep->var_78; - - sint16 ax = word_981D6C[peepDirection].x; - sint16 cx = word_981D6C[peepDirection].y; - - ax *= -12; - cx *= -12; - - ax += vehicle->x; - cx += vehicle->y; - - peep->destination_x = ax; - peep->destination_y = cx; - peep->destination_tolerence = 2; - - loc_6C0FAA(steps, peep, ride); -} - -static void loc_6C0FAA(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_xy_distance; + if (!firstRun) { + uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; + + if (vehicleIndex == 0xFFFF) { + return true; + } + + rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); + for (uint8 i = 0; i < ride->broken_car; i++) { + vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); + } + + while (true) { + if (vehicle->is_child == 0) { + break; + } + + uint8 trackType = vehicle->track_type >> 2; + if (trackType == TRACK_ELEM_END_STATION) { + break; + } + + if (trackType == TRACK_ELEM_BEGIN_STATION) { + break; + } + + if (trackType == TRACK_ELEM_MIDDLE_STATION) { + break; + } + + vehicle = GET_VEHICLE(vehicle->prev_vehicle_on_ride); + } + + rct_xy16 offset = word_981D6C[peep->var_78]; + peep->destination_x = (offset.x * -12) + vehicle->x; + peep->destination_y = (offset.y * -12) + vehicle->y; + peep->destination_tolerence = 2; + } + invalidate_sprite_2((rct_sprite *) peep); if (peep_update_action(&x, &y, &tmp_xy_distance, peep)) { sprite_move(x, y, peep->z, (rct_sprite *) peep); invalidate_sprite_2((rct_sprite *) peep); - return; + return false; } - loc_6C1653(steps, peep, ride); + return true; } -void loc_6C0FD3(int steps, rct_peep *peep, rct_ride *ride) { - peep->sprite_direction = peep->var_78 << 3; - - peep->action = PEEP_ACTION_STAFF_FIX; - if (scenario_rand() & 0x100000) { - peep->action = PEEP_ACTION_STAFF_FIX_2; - } - - // loc_6C0FFB: - peep->action_sprite_image_offset = 0; - peep->action_frame = 0; - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C100D(steps, peep, ride); -} - -static void loc_6C100D(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_distance; + if (!firstRun) { + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX; + if (scenario_rand() & 0x100000) { + peep->action = PEEP_ACTION_STAFF_FIX_2; + } + + peep->action_sprite_image_offset = 0; + peep->action_frame = 0; + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action == 0xFF) { - loc_6C1653(steps, peep, ride); - return; + return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_distance, peep); - uint8 al = peep->action; - sint8 ah = 0x25; - if (al != 0x0F) { - ah = 0x50; + uint8 actionFrame = 0x25; + if (peep->action != 0x0F) { + actionFrame = 0x50; } - // loc_6C1027 - if (peep->action_frame != ah) { - return; + if (peep->action_frame != actionFrame) { + return false; } - uint32 ebx = ride->broken_vehicle; - uint16 bp = ride->vehicles[ebx]; + uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; - if (bp == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; + if (vehicleIndex == 0xFFFF) { + return true; } - rct_sprite *sprite = &g_sprite_list[bp]; - ah = ride->broken_car; + rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); + for (uint8 i = 0; i < ride->broken_car; i++) { + vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); + } - // loc_6C1061 - do { - ah--; - if (ah < 0) { - sprite->vehicle.update_flags = 0xFEFF; - return;; - } + vehicle->update_flags = 0xFEFF; - sprite = &g_sprite_list[sprite->vehicle.next_vehicle_on_train]; - } while (true); + return false; } -void loc_6C107B(int steps, rct_peep *peep, rct_ride *ride) { - peep->sprite_direction = peep->var_78 << 3; - peep->action = 18; - peep->action_sprite_image_offset = 0; - peep->action_frame = 0; - - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C10A5(steps, peep, ride); -} - -static void loc_6C10A5(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_distance; + if (!firstRun) { + peep->sprite_direction = peep->var_78 << 3; + peep->action = 18; + peep->action_sprite_image_offset = 0; + peep->action_frame = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action == 0xFF) { - loc_6C1653(steps, peep, ride); - return; + return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_distance, peep); if (peep->action_frame != 0x65) { - return; + return false; } - // loc_6C10C5 - uint32 ebx = ride->broken_vehicle; - uint16 bp = ride->vehicles[ebx]; - if (bp == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; + uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; + if (vehicleIndex == 0xFFFF) { + return true; } - rct_sprite *sprite = &g_sprite_list[bp]; - sint8 ah = ride->broken_car; + rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); + for (uint8 i = 0; i < ride->broken_car; i++) { + vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); + } - // loc_6C10FA: - while (true) { - ah--; - if (ah < 0) { - // loc_6C110D: - sprite->vehicle.update_flags &= 0xFDFF; - return; + vehicle->update_flags &= 0xFDFF; + + return false; +} + +static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_distance; + + if (!firstRun) { + if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { + return true; } - sprite = &g_sprite_list[sprite->vehicle.next_vehicle_on_train]; + uint16 stationPosition = ride->station_starts[peep->current_ride_station]; + if (stationPosition == 0xFFFF) { + return true; + } + + uint8 stationZ = ride->station_heights[peep->current_ride_station]; + uint16 stationX = (stationPosition & 0xFF) * 32; + uint16 stationY = (stationPosition >> 8) * 32; + + rct_map_element *mapElement = map_get_track_element_at(stationX, stationY, stationZ); + if (mapElement == NULL) { + log_error("Couldn't find map_element"); + return false; + } + + int direction = map_element_get_direction(mapElement); + rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; + + stationX += 10 + offset.x; + if (offset.x == 0) { + stationX = peep->destination_x; + } + + stationY += 10 + offset.y; + if (offset.y == 0) { + stationY = peep->destination_y; + } + + peep->destination_x = stationX; + peep->destination_y = stationY; + peep->destination_tolerence = 2; } -} - -void loc_6C1114(int steps, rct_peep *peep, rct_ride *ride) { - - if (ride_type_has_flag(ride->type, 0x8008)) { - loc_6C1653(steps, peep, ride); - return; - } - - uint16 ax = ride->station_starts[peep->current_ride_station]; - if (ax == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; - } - - - uint8 dl = ride->station_heights[peep->current_ride_station]; - - - uint16 cx = 0; - uint8 cl = ax >> 8; - uint8 al = ax & 0xFF; - - ax = al << 5; - cx = cl << 5; - - // loc_6C1175: - rct_map_element *mapElement = map_get_track_element_at(ax, cx, dl); - if (mapElement == NULL) { - log_error("Couldn't find map_element"); - return; - } - - // loc_6C118A: - int ebx = map_element_get_direction(mapElement); - ax += 10; - cx += 10; - uint16 dx = RCT2_ADDRESS(0x992A3C, uint16)[ebx * 2]; - ax += dx; - if (dx == 0) { - ax = peep->destination_x; - } - - // loc_6C11AC: - dx = RCT2_ADDRESS(0x992A3E, uint16)[ebx * 2]; - cx += dx; - if (dx == 0) { - cx = peep->destination_y; - } - - // loc_6C11C0: - peep->destination_x = ax; - peep->destination_y = cx; - peep->destination_tolerence = 2; - - loc_6C11CC(steps, peep, ride); -} - -static void loc_6C11CC(int steps, rct_peep *peep, rct_ride *ride) { - sint16 x, y, tmp_distance; invalidate_sprite_2((rct_sprite *) peep); int out = peep_update_action(&x, &y, &tmp_distance, peep); if (out == 0) { - loc_6C1653(steps, peep, ride); - return; + return true; } sprite_move(x, y, peep->z, (rct_sprite *) peep); invalidate_sprite_2((rct_sprite *) peep); + + return false; } -void loc_6C11F5(int steps, rct_peep *peep, rct_ride *ride) { - // eax: steps - // esi: peep - // edi: ride - - uint8 direction = peep->var_78 << 3; - peep->sprite_direction = direction; - peep->action = PEEP_ACTION_STAFF_CHECKBOARD; - peep->action_frame = 0; - peep->action_sprite_image_offset = 0; - - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C121F(steps, peep, ride); -} - -static void loc_6C121F(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) { sint16 tmp_x, tmp_y, tmp_xy_distance; + if (!firstRun) { + peep->sprite_direction = peep->var_78 << 3; + peep->action = PEEP_ACTION_STAFF_CHECKBOARD; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action == 0xFF) { - loc_6C1653(steps, peep, ride); - return; + return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); + + return false; } -void loc_6C1239(int steps, rct_peep *peep, rct_ride *ride) { - // eax: steps - // esi: peep - // edi: ride +static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride) { + if (!firstRun) { + if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { + return true; + } - if (!ride_type_has_flag(ride->type, 0x8008)) { - loc_6C1653(steps, peep, ride); - return; + uint16 stationPosition = ride->station_starts[peep->current_ride_station]; + + if (stationPosition == 0xFFFF) { + return true; + } + + uint8 stationZ = ride->station_heights[peep->current_ride_station]; + uint8 currentRide = peep->current_ride; + + uint16 stationX = (stationPosition & 0xFF) * 32; + uint16 stationY = (stationPosition >> 8) * 32; + + return loc_6C1288(peep, ride, stationX, stationY, currentRide, stationZ); } - uint16 ax = ride->station_starts[peep->current_ride_station]; - - if (ax == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; - } - - uint8 dl = ride->station_heights[peep->current_ride_station]; - uint8 dh = peep->current_ride; - - uint16 cx = ax >> 8; - ax &= 0x00FF; - - ax = ax << 5; - cx = cx << 5; - - loc_6C1288(steps, peep, ride, ax, cx, dh, dl); + return peep_update_fixing_sub_state_9_a(peep); } -void static loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uint16 cx, uint8 dh, uint8 dl) { +static bool loc_6C1288(rct_peep *peep, rct_ride *ride, uint16 stationX, uint16 stationY, uint8 currentRide, uint8 stationZ) { - uint32 ebp = ((cx << 8) | ax) >> 3; + uint32 ebp = ((stationY << 8) | stationX) >> 3; rct_map_element *ebp_tile = TILE_MAP_ELEMENT_POINTER(ebp / 8); do { @@ -3847,11 +3782,11 @@ void static loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uin if (map_element_get_type(ebp_tile) != 8) { continue; } - if (ebp_tile->properties.track.ride_index != dh) { + if (ebp_tile->properties.track.ride_index != currentRide) { continue; } - if (ebp_tile->base_height != dl) { + if (ebp_tile->base_height != stationZ) { continue; } @@ -3862,10 +3797,9 @@ void static loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uin uint8 direction = ebp_tile->type & 3; RCT2_GLOBAL(0xF43914, uint32) = direction; - ax -= TileDirectionDelta[direction].x; - cx -= TileDirectionDelta[direction].y; - loc_6C1288(steps, peep, ride, ax, cx, dh, dl); - return;; + stationX -= TileDirectionDelta[direction].x; + stationY -= TileDirectionDelta[direction].y; + return loc_6C1288(peep, ride, stationX, stationY, currentRide, stationZ); } // loc_6C12C4: @@ -3873,342 +3807,233 @@ void static loc_6C1288(int steps, rct_peep *peep, rct_ride *ride, uint16 ax, uin // loc_6C12ED: uint8 direction = RCT2_GLOBAL(0xF43914, uint32); - ax += TileDirectionDelta[direction].x; - cx += TileDirectionDelta[direction].y; + stationX += TileDirectionDelta[direction].x; + stationY += TileDirectionDelta[direction].y; - ax += 0x10; - cx += 0x10; + stationX += 0x10; + stationY += 0x10; - sint16 delta_2_x = RCT2_ADDRESS(0x992A3C, uint16)[direction * 2]; // TODO: Is this an rct_xy16? - ax -= delta_2_x; - if (delta_2_x == 0) { - ax = peep->destination_x; + rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; + + stationX -= offset.x; + if (offset.x == 0) { + stationX = peep->destination_x; } - sint16 delta_2_y = RCT2_ADDRESS(0x992A3E, uint16)[direction * 2];// TODO: Is this an rct_xy16? - cx -= delta_2_y; - if (delta_2_y == 0) { - cx = peep->destination_y; + stationY -= offset.y; + if (offset.y == 0) { + stationY = peep->destination_y; } - peep->destination_x = ax; - peep->destination_y = cx; + peep->destination_x = stationX; + peep->destination_y = stationY; peep->destination_tolerence = 2; - loc_6C133F(steps, peep, ride); + return peep_update_fixing_sub_state_9_a(peep); } -static void loc_6C133F(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_9_a(rct_peep *peep) { sint16 x, y, tmp_xy_distance; invalidate_sprite_2((rct_sprite *) peep); - int out = peep_update_action(&x, &y, &tmp_xy_distance, peep); - if (out == 0) { - loc_6C1653(steps, peep, ride); - return; + if (!peep_update_action(&x, &y, &tmp_xy_distance, peep)) { + return true; } sprite_move(x, y, peep->z, (rct_sprite *) peep); invalidate_sprite_2((rct_sprite *) peep); + + return false; } -void loc_6C1368(int steps, rct_peep *peep, rct_ride *ride) { - if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 & RIDE_TYPE_FLAG_15)) { - loc_6C1653(steps, peep, ride); - return;; - } - - peep->sprite_direction = peep->var_78 << 3; - - peep->action = PEEP_ACTION_STAFF_FIX; - peep->action_frame = 0; - peep->action_sprite_image_offset = 0; - - - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C13B4(steps, peep, ride); -} - -static void loc_6C13B4(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; + if (!firstRun) { + if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 & RIDE_TYPE_FLAG_15)) { + return true; + } + + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action == 0xFF) { - loc_6C1653(steps, peep, ride); - return; + return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); + + return false; } -void loc_6C13CE(int steps, rct_peep *peep, rct_ride *ride) { - peep->sprite_direction = peep->var_78 << 3; - - peep->action = PEEP_ACTION_STAFF_FIX_GROUND; - peep->action_frame = 0; - peep->action_sprite_image_offset = 0; - - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C13F8(steps, peep, ride); -} - -static void loc_6C13F8(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; + if (!firstRun) { + peep->sprite_direction = peep->var_78 << 3; + + peep->action = PEEP_ACTION_STAFF_FIX_GROUND; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action == 0xFF) { - loc_6C1653(steps, peep, ride); - return; + return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); if (peep->action_frame == 0x28) { ride->mechanic_status = 4; - ride->window_invalidate_flags |= 0x20; + ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE; } - // loc_6C142F if (peep->action_frame == 0x13 || peep->action_frame == 0x19 || peep->action_frame == 0x1F || peep->action_frame == 0x25 || peep->action_frame == 0x2B) { - // loc_6C144E: audio_play_sound_at_location(SOUND_MECHANIC_FIX, peep->x, peep->y, peep->z); } + + return false; } -void loc_6C1474(int steps, rct_peep *peep, rct_ride *ride) { - uint8 ebx = peep->current_ride_station; - - uint16 ax = ride->exits[ebx]; - if (ax == 0xFFFF) { - ax = ride->entrances[ebx]; - - if (ax == 0xFFFF) { - loc_6C1653(steps, peep, ride); - return; - } - } - - // loc_6C14A2: - - uint16 cx = ax >> 8; - ax &= 0x00FF; - - ax = ax << 5; - cx = cx << 5; - - ax += 16; - cx += 10; - - rct_xy16 direction = word_981D6C[peep->var_78]; - - - ax += direction.x * 20; - cx += direction.y * 20; - - peep->destination_x = ax; - peep->destination_y = cx; - peep->destination_tolerence = 2; - - loc_6C14E5(steps, peep, ride); -} - -static void loc_6C14E5(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_xy_distance; + if (!firstRun) { + uint16 stationPosition = ride->exits[peep->current_ride_station]; + if (stationPosition == 0xFFFF) { + stationPosition = ride->entrances[peep->current_ride_station]; + + if (stationPosition == 0xFFFF) { + return true; + } + } + + uint16 stationX = (stationPosition & 0xFF) * 32; + uint16 stationY = (stationPosition >> 8) * 32; + + stationX += 16; + stationY += 10; + + rct_xy16 direction = word_981D6C[peep->var_78]; + + stationX += direction.x * 20; + stationY += direction.y * 20; + + peep->destination_x = stationX; + peep->destination_y = stationY; + peep->destination_tolerence = 2; + } + invalidate_sprite_2((rct_sprite *) peep); if (peep_update_action(&x, &y, &tmp_xy_distance, peep) == 0) { - loc_6C1653(steps, peep, ride); + return true; } else { sprite_move(x, y, peep->z, (rct_sprite *) peep); invalidate_sprite_2((rct_sprite *) peep); } + + return false; } -void loc_6C1504(int steps, rct_peep *peep, rct_ride *ride) { - if (peep->state == PEEP_STATE_INSPECTING) { - sub_6B7588(peep, peep->current_ride); - - peep->staff_rides_inspected++; - peep->window_invalidate_flags |= 10; - loc_6C1653(steps, peep, ride); - return; - } - - // loc_6C1524: - peep->staff_rides_fixed++; - peep->window_invalidate_flags |= 10; - - peep->sprite_direction = peep->var_78 << 3; - peep->action = PEEP_ACTION_STAFF_ANSWER_CALL_2; - peep->action_frame = 0; - peep->action_sprite_image_offset = 0; - - sub_693B58(peep); - invalidate_sprite_2((rct_sprite *) peep); - - loc_6C1559(steps, peep, ride); -} - -static void loc_6C1559(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_13(bool firstRun, int steps, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; + if (!firstRun) { + if (peep->state == PEEP_STATE_INSPECTING) { + sub_6B7588(peep->current_ride); + + peep->staff_rides_inspected++; + peep->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME | RIDE_INVALIDATE_RIDE_LIST; + + return true; + } + + peep->staff_rides_fixed++; + peep->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME | RIDE_INVALIDATE_RIDE_LIST; + + peep->sprite_direction = peep->var_78 << 3; + peep->action = PEEP_ACTION_STAFF_ANSWER_CALL_2; + peep->action_frame = 0; + peep->action_sprite_image_offset = 0; + + sub_693B58(peep); + invalidate_sprite_2((rct_sprite *) peep); + } + if (peep->action != 0xFF) { peep_update_action(&tmp_x, &tmp_y, &tmp_xy_distance, peep); - return; + return false; } - // loc_6C156F: - ride_fix_breakdown(peep->current_ride, steps); // TODO: What should be the reliabilityIncreaseFactor? + ride_fix_breakdown(peep->current_ride, steps); - loc_6C1653(steps, peep, ride); + return true; } -void loc_6C157E(int steps, rct_peep *peep, rct_ride *ride) { - uint32 ebx = peep->current_ride_station; - - uint16 ax = ride->exits[ebx]; - if (ax == 0xFFFF) { - ax = ride->entrances[ebx]; - - if (ax == 0xFFFF) { - // loc_6C1644: - peep_decrement_num_riders(peep); - peep->state = 0; - peep_window_state_update(peep); - return; - } - } - - // loc_6C15AC - - uint16 cx = ax >> 8; - ax = ax & 0x00FF; - ax = ax << 5; - cx = cx << 5; - - ebx = peep->var_78; - - ax += 16; - cx += 16; - - rct_xy16 ebx_direction = word_981D6C[ebx]; - ax -= ebx_direction.x * 19; - cx -= ebx_direction.y * 19; - - peep->destination_x = ax; - peep->destination_y = cx; - peep->destination_tolerence = 2; - - loc_6C15EF(steps, peep, ride); -} - -static void loc_6C15EF(int steps, rct_peep *peep, rct_ride *ride) { +static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, xy_distance; + if (!firstRun) { + uint16 exitPosition = ride->exits[peep->current_ride_station]; + if (exitPosition == 0xFFFF) { + exitPosition = ride->entrances[peep->current_ride_station]; + + if (exitPosition == 0xFFFF) { + peep_decrement_num_riders(peep); + peep->state = 0; + peep_window_state_update(peep); + return false; + } + } + + uint16 exitX = (exitPosition & 0xFF) * 32; + uint16 exitY = (exitPosition >> 8) * 32; + + exitX += 16; + exitY += 16; + + rct_xy16 ebx_direction = word_981D6C[peep->var_78]; + exitX -= ebx_direction.x * 19; + exitY -= ebx_direction.y * 19; + + peep->destination_x = exitX; + peep->destination_y = exitY; + peep->destination_tolerence = 2; + } + invalidate_sprite_2((rct_sprite *) peep); - int out = peep_update_action(&x, &y, &xy_distance, peep); - if (out == 0) { - // loc_6C1644: + if (peep_update_action(&x, &y, &xy_distance, peep) == 0) { peep_decrement_num_riders(peep); peep->state = 0; peep_window_state_update(peep); - return; + + return false; } - uint16 z = ride->station_heights[peep->current_ride_station]; - z = z << 3; + uint16 z = ride->station_heights[peep->current_ride_station] * 8; if (xy_distance >= 16) { z += RCT2_ADDRESS(0x0097D21C, uint8)[ride->type * 8]; } - // loc_6C1639: sprite_move(x, y, z, (rct_sprite *) peep); - invalidate_sprite_2((rct_sprite *) peep);; -} + invalidate_sprite_2((rct_sprite *) peep); -void loc_6C1653(int steps, rct_peep *peep, rct_ride *ride) { - // eax: steps - // esi: peep - // edi: ride - - int edx = peep->sub_state; - uint32 ebp = RCT2_ADDRESS(0x992A18, uint32)[8]; - - if (peep->state != PEEP_STATE_INSPECTING) { - ebp = ride->breakdown_reason_pending; - ebp = RCT2_ADDRESS(0x992A18, uint32)[ride->breakdown_reason_pending]; - } - - // loc_6C167B - do { - edx++; - } while ((ebp & (1 << edx)) == 0); - - peep->sub_state = edx & 0xFF; - - // off_6C168C - switch (edx) { - case 0: - loc_6C0EEC(steps, peep, ride); - break; - - case 1: - loc_6C0F09(steps, peep, ride); - break; - - case 2: - case 3: - case 4: - case 5: - loc_6C0FD3(steps, peep, ride); - break; - - case 6: - loc_6C107B(steps, peep, ride); - break; - - case 7: - loc_6C1114(steps, peep, ride); - break; - - case 8: - loc_6C11F5(steps, peep, ride); - break; - - case 9: - loc_6C1239(steps, peep, ride); - break; - - case 10: - loc_6C1368(steps, peep, ride); - break; - - case 11: - loc_6C13CE(steps, peep, ride); - break; - - case 12: - loc_6C1474(steps, peep, ride); - break; - - case 13: - loc_6C1504(steps, peep, ride); - break; - - case 14: - loc_6C157E(steps, peep, ride); - break; - - default: - RCT2_CALLPROC_X(RCT2_ADDRESS(0x006C0EB0, uint32)[peep->sub_state], steps, 0, 0, 0, (int) peep, (int) ride, 0); - } + return false; } /** From 7565a7ba6908e95c4a48f267cba83fd7a3681d9b Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Fri, 12 Feb 2016 16:40:17 +0100 Subject: [PATCH 04/11] Implement substate 9 --- src/peep/peep.c | 113 ++++++++++++++++++------------------------------ src/world/map.c | 21 +++++++++ src/world/map.h | 1 + 3 files changed, 63 insertions(+), 72 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 391c42717c..2e9f67c82e 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -42,6 +42,7 @@ #include "peep.h" #include "staff.h" #include "../ride/vehicle.h" +#include "../world/map.h" enum { PATH_SEARCH_DEAD_END, @@ -3748,93 +3749,61 @@ static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) { } static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride) { + sint16 x, y, tmp_xy_distance; + if (!firstRun) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { return true; } uint16 stationPosition = ride->station_starts[peep->current_ride_station]; - if (stationPosition == 0xFFFF) { return true; } uint8 stationZ = ride->station_heights[peep->current_ride_station]; - uint8 currentRide = peep->current_ride; - uint16 stationX = (stationPosition & 0xFF) * 32; - uint16 stationY = (stationPosition >> 8) * 32; + rct_xy_element input; + input.x = (stationPosition & 0xFF) * 32; + input.y = (stationPosition >> 8) * 32; + input.element = map_get_track_element_at_from_ride(input.x, input.y, stationZ, peep->current_ride); - return loc_6C1288(peep, ride, stationX, stationY, currentRide, stationZ); + track_begin_end *trackBeginEnd; + while (track_block_get_previous(input.x, input.y, input.element, trackBeginEnd)) { + uint8 trackType = trackBeginEnd->begin_element->properties.track.type; + if (trackType == 2 || trackType == 3 || trackType == 1) { + input.x = trackBeginEnd->begin_x; + input.y = trackBeginEnd->begin_y; + + RCT2_GLOBAL(0xF43914, uint32) = trackBeginEnd->begin_element->type & 3; + continue; + } + + break; + } + + // loc_6C12ED: + uint8 direction = RCT2_GLOBAL(0xF43914, uint32); + uint16 destinationX = input.x + TileDirectionDelta[direction].x + 16; + uint16 destinationY = input.y + TileDirectionDelta[direction].y + 16; + + rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; + + destinationX -= offset.x; + if (offset.x == 0) { + destinationX = peep->destination_x; + } + + destinationY -= offset.y; + if (offset.y == 0) { + destinationY = peep->destination_y; + } + + peep->destination_x = destinationX; + peep->destination_y = destinationY; + peep->destination_tolerence = 2; } - return peep_update_fixing_sub_state_9_a(peep); -} - -static bool loc_6C1288(rct_peep *peep, rct_ride *ride, uint16 stationX, uint16 stationY, uint8 currentRide, uint8 stationZ) { - - uint32 ebp = ((stationY << 8) | stationX) >> 3; - rct_map_element *ebp_tile = TILE_MAP_ELEMENT_POINTER(ebp / 8); - - do { - // loc_6C129D: - - if (map_element_get_type(ebp_tile) != 8) { - continue; - } - if (ebp_tile->properties.track.ride_index != currentRide) { - continue; - } - - if (ebp_tile->base_height != stationZ) { - continue; - } - - uint8 trackType = ebp_tile->properties.track.type; - if (trackType == 2 || trackType == 3 || trackType == 1) { - // loc_6C12CF: - - uint8 direction = ebp_tile->type & 3; - RCT2_GLOBAL(0xF43914, uint32) = direction; - - stationX -= TileDirectionDelta[direction].x; - stationY -= TileDirectionDelta[direction].y; - return loc_6C1288(peep, ride, stationX, stationY, currentRide, stationZ); - } - - // loc_6C12C4: - } while (!map_element_is_last_for_tile(ebp_tile++)); - - // loc_6C12ED: - uint8 direction = RCT2_GLOBAL(0xF43914, uint32); - stationX += TileDirectionDelta[direction].x; - stationY += TileDirectionDelta[direction].y; - - stationX += 0x10; - stationY += 0x10; - - rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; - - stationX -= offset.x; - if (offset.x == 0) { - stationX = peep->destination_x; - } - - stationY -= offset.y; - if (offset.y == 0) { - stationY = peep->destination_y; - } - - peep->destination_x = stationX; - peep->destination_y = stationY; - peep->destination_tolerence = 2; - - return peep_update_fixing_sub_state_9_a(peep); -} - -static bool peep_update_fixing_sub_state_9_a(rct_peep *peep) { - sint16 x, y, tmp_xy_distance; - invalidate_sprite_2((rct_sprite *) peep); if (!peep_update_action(&x, &y, &tmp_xy_distance, peep)) { diff --git a/src/world/map.c b/src/world/map.c index 477ffb93d9..3f10eebcfb 100644 --- a/src/world/map.c +++ b/src/world/map.c @@ -5302,3 +5302,24 @@ rct_map_element *map_get_track_element_at_of_type_from_ride(int x, int y, int z, return NULL; }; + +/** + * Gets the track element at x, y, z that is the given track type and sequence. + * @param x x units, not tiles. + * @param y y units, not tiles. + * @param z Base height. + * @param ride index + */ +rct_map_element *map_get_track_element_at_from_ride(int x, int y, int z, int rideIndex) { + rct_map_element *mapElement = map_get_first_element_at(x >> 5, y >> 5); + do { + if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue; + if (mapElement->base_height != z) continue; + if (mapElement->properties.track.ride_index != rideIndex) continue; + + return mapElement; + } while (!map_element_is_last_for_tile(mapElement++)); + + return NULL; +}; + diff --git a/src/world/map.h b/src/world/map.h index ccb4408bc4..c1ce1865e5 100644 --- a/src/world/map.h +++ b/src/world/map.h @@ -399,5 +399,6 @@ rct_map_element *map_get_track_element_at(int x, int y, int z); rct_map_element *map_get_track_element_at_of_type(int x, int y, int z, int trackType); rct_map_element *map_get_track_element_at_of_type_seq(int x, int y, int z, int trackType, int sequence); rct_map_element *map_get_track_element_at_of_type_from_ride(int x, int y, int z, int trackType, int rideIndex); +rct_map_element *map_get_track_element_at_from_ride(int x, int y, int z, int rideIndex); #endif From 44cd07f9c6c53c8de846d308ba9947b9d4952cf8 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Fri, 12 Feb 2016 19:24:21 +0100 Subject: [PATCH 05/11] Let code make more sense --- src/peep/peep.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 2e9f67c82e..0a64add78f 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -3752,7 +3752,7 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri sint16 x, y, tmp_xy_distance; if (!firstRun) { - if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { + if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { return true; } @@ -3766,16 +3766,21 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri rct_xy_element input; input.x = (stationPosition & 0xFF) * 32; input.y = (stationPosition >> 8) * 32; + + char buffer[256]; + format_string(buffer, ride->name, &ride->name_arguments); + log_info("%s", buffer); input.element = map_get_track_element_at_from_ride(input.x, input.y, stationZ, peep->current_ride); - track_begin_end *trackBeginEnd; - while (track_block_get_previous(input.x, input.y, input.element, trackBeginEnd)) { - uint8 trackType = trackBeginEnd->begin_element->properties.track.type; + track_begin_end trackBeginEnd; + while (track_block_get_previous(input.x, input.y, input.element, &trackBeginEnd)) { + uint8 trackType = trackBeginEnd.begin_element->properties.track.type; if (trackType == 2 || trackType == 3 || trackType == 1) { - input.x = trackBeginEnd->begin_x; - input.y = trackBeginEnd->begin_y; + input.x = trackBeginEnd.begin_x; + input.y = trackBeginEnd.begin_y; + input.element = trackBeginEnd.begin_element; - RCT2_GLOBAL(0xF43914, uint32) = trackBeginEnd->begin_element->type & 3; + RCT2_GLOBAL(0xF43914, uint32) = trackBeginEnd.begin_element->type & 3; continue; } From 1c04745136eca4a9bdfad81bd4bd9e6550228055 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Fri, 12 Feb 2016 21:55:01 +0100 Subject: [PATCH 06/11] Clean up --- src/peep/peep.c | 44 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 39 insertions(+), 5 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 0a64add78f..d2b5d8504d 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -41,8 +41,6 @@ #include "../cheats.h" #include "peep.h" #include "staff.h" -#include "../ride/vehicle.h" -#include "../world/map.h" enum { PATH_SEARCH_DEAD_END, @@ -3529,6 +3527,9 @@ static void peep_update_fixing(int steps, rct_peep* peep){ } } +/** + * rct2: 0x006C0EEC + */ static bool peep_update_fixing_sub_state_0(rct_ride *ride) { ride->mechanic_status = RIDE_MECHANIC_STATUS_FIXING; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE; @@ -3536,6 +3537,9 @@ static bool peep_update_fixing_sub_state_0(rct_ride *ride) { return true; } +/** + * rct2: 0x006C0F09 + */ static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_xy_distance; @@ -3588,6 +3592,9 @@ static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ri return true; } +/** + * rct2: 0x006C0FD3 + */ static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_distance; @@ -3636,6 +3643,9 @@ static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct return false; } +/** + * rct2: 0x006C107B + */ static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_distance; @@ -3673,6 +3683,9 @@ static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ri return false; } +/** + * rct2: 0x006C1114 + */ static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_distance; @@ -3699,12 +3712,12 @@ static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ri int direction = map_element_get_direction(mapElement); rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; - stationX += 10 + offset.x; + stationX += 16 + offset.x; if (offset.x == 0) { stationX = peep->destination_x; } - stationY += 10 + offset.y; + stationY += 16 + offset.y; if (offset.y == 0) { stationY = peep->destination_y; } @@ -3726,6 +3739,9 @@ static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ri return false; } +/** + * rct2: 0x006C11F5 + */ static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) { sint16 tmp_x, tmp_y, tmp_xy_distance; @@ -3748,6 +3764,9 @@ static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) { return false; } +/** + * rct2: 0x006C1239 + */ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_xy_distance; @@ -3821,6 +3840,9 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri return false; } +/** + * rct2: 0x006C1368 + */ static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; @@ -3848,6 +3870,9 @@ static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_r return false; } +/** + * rct2: 0x006C13CE + */ static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; @@ -3883,6 +3908,9 @@ static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_r return false; } +/** + * rct2: 0x006C1474 + */ static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, tmp_xy_distance; @@ -3900,7 +3928,7 @@ static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_r uint16 stationY = (stationPosition >> 8) * 32; stationX += 16; - stationY += 10; + stationY += 16; rct_xy16 direction = word_981D6C[peep->var_78]; @@ -3923,6 +3951,9 @@ static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_r return false; } +/** + * rct2: 0x006C1504 + */ static bool peep_update_fixing_sub_state_13(bool firstRun, int steps, rct_peep *peep, rct_ride *ride) { sint16 tmp_x, tmp_y, tmp_xy_distance; @@ -3958,6 +3989,9 @@ static bool peep_update_fixing_sub_state_13(bool firstRun, int steps, rct_peep * return true; } +/** + * rct2: 0x006C157E + */ static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_ride *ride) { sint16 x, y, xy_distance; From 5ef00a28edafad9fff0aef8745bb65ad4c6cda69 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Fri, 12 Feb 2016 22:42:44 +0100 Subject: [PATCH 07/11] Process feedback --- src/peep/peep.c | 116 +++++++++++++++++------------------------------- src/peep/peep.h | 1 + src/ride/ride.c | 15 +++++++ src/ride/ride.h | 1 + 4 files changed, 57 insertions(+), 76 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index d2b5d8504d..395e44b597 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -97,12 +97,7 @@ static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride); static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride); static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep); - static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride); - -static bool loc_6C1288(rct_peep *peep, rct_ride *ride, uint16 stationX, uint16 stationY, uint8 currentRide, uint8 stationZ); - -static bool peep_update_fixing_sub_state_9_a(rct_peep *peep); static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride); static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride); static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride); @@ -3444,86 +3439,85 @@ static void peep_update_fixing(int steps, rct_peep* peep){ return; } - bool do_6c1653 = true; + bool progressToNextSubstate = true; bool firstRun = true; - while (do_6c1653) { + while (progressToNextSubstate) { switch (peep->sub_state) { case 0: - do_6c1653 = peep_update_fixing_sub_state_0(ride); + progressToNextSubstate = peep_update_fixing_sub_state_0(ride); break; case 1: - do_6c1653 = peep_update_fixing_sub_state_1(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_1(firstRun, peep, ride); break; case 2: case 3: case 4: case 5: - do_6c1653 = peep_update_fixing_sub_state_2345(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_2345(firstRun, peep, ride); break; case 6: - do_6c1653 = peep_update_fixing_sub_state_6(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_6(firstRun, peep, ride); break; case 7: - do_6c1653 = peep_update_fixing_sub_state_7(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_7(firstRun, peep, ride); break; case 8: - do_6c1653 = peep_update_fixing_sub_state_8(firstRun, peep); + progressToNextSubstate = peep_update_fixing_sub_state_8(firstRun, peep); break; case 9: - do_6c1653 = peep_update_fixing_sub_state_9(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_9(firstRun, peep, ride); break; case 10: - do_6c1653 = peep_update_fixing_sub_state_10(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_10(firstRun, peep, ride); break; case 11: - do_6c1653 = peep_update_fixing_sub_state_11(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_11(firstRun, peep, ride); break; case 12: - do_6c1653 = peep_update_fixing_sub_state_12(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_12(firstRun, peep, ride); break; case 13: - do_6c1653 = peep_update_fixing_sub_state_13(firstRun, steps, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_13(firstRun, steps, peep, ride); break; case 14: - do_6c1653 = peep_update_fixing_sub_state_14(firstRun, peep, ride); + progressToNextSubstate = peep_update_fixing_sub_state_14(firstRun, peep, ride); break; default: log_error("Invalid substate"); - do_6c1653 = false; + progressToNextSubstate = false; } firstRun = false; - if (!do_6c1653) { + if (!progressToNextSubstate) { break; } - int edx = peep->sub_state; + int subState = peep->sub_state; uint32 ebp = RCT2_ADDRESS(0x992A18, uint32)[8]; if (peep->state != PEEP_STATE_INSPECTING) { ebp = RCT2_ADDRESS(0x992A18, uint32)[ride->breakdown_reason_pending]; } - // loc_6C167B do { - edx++; - } while ((ebp & (1 << edx)) == 0); + subState++; + } while ((ebp & (1 << subState)) == 0); - peep->sub_state = edx & 0xFF; + peep->sub_state = subState & 0xFF; } } @@ -3544,17 +3538,11 @@ static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ri sint16 x, y, tmp_xy_distance; if (!firstRun) { - uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; - - if (vehicleIndex == 0xFFFF) { + rct_vehicle *vehicle = ride_get_broken_vehicle(ride); + if (vehicle == NULL) { return true; } - rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); - for (uint8 i = 0; i < ride->broken_car; i++) { - vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); - } - while (true) { if (vehicle->is_child == 0) { break; @@ -3601,44 +3589,30 @@ static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct if (!firstRun) { peep->sprite_direction = peep->var_78 << 3; - peep->action = PEEP_ACTION_STAFF_FIX; - if (scenario_rand() & 0x100000) { - peep->action = PEEP_ACTION_STAFF_FIX_2; - } - + peep->action = (scenario_rand() & 1) ? PEEP_ACTION_STAFF_FIX_2 : PEEP_ACTION_STAFF_FIX; peep->action_sprite_image_offset = 0; peep->action_frame = 0; sub_693B58(peep); invalidate_sprite_2((rct_sprite *) peep); } - if (peep->action == 0xFF) { + if (peep->action == PEEP_ACTION_NONE_2) { return true; } peep_update_action(&tmp_x, &tmp_y, &tmp_distance, peep); - uint8 actionFrame = 0x25; - if (peep->action != 0x0F) { - actionFrame = 0x50; - } - + uint8 actionFrame = (peep->action == PEEP_ACTION_STAFF_FIX) ? 0x25 : 0x50; if (peep->action_frame != actionFrame) { return false; } - uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; - - if (vehicleIndex == 0xFFFF) { + rct_vehicle *vehicle = ride_get_broken_vehicle(ride); + if (vehicle == NULL) { return true; } - rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); - for (uint8 i = 0; i < ride->broken_car; i++) { - vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); - } - - vehicle->update_flags = 0xFEFF; + vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_BROKEN_CAR; return false; } @@ -3651,7 +3625,7 @@ static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ri if (!firstRun) { peep->sprite_direction = peep->var_78 << 3; - peep->action = 18; + peep->action = PEEP_ACTION_STAFF_FIX_3; peep->action_sprite_image_offset = 0; peep->action_frame = 0; @@ -3659,7 +3633,7 @@ static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ri invalidate_sprite_2((rct_sprite *) peep); } - if (peep->action == 0xFF) { + if (peep->action == PEEP_ACTION_NONE_2) { return true; } @@ -3668,17 +3642,12 @@ static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ri return false; } - uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; - if (vehicleIndex == 0xFFFF) { + rct_vehicle *vehicle = ride_get_broken_vehicle(ride); + if (vehicle == NULL) { return true; } - rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); - for (uint8 i = 0; i < ride->broken_car; i++) { - vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); - } - - vehicle->update_flags &= 0xFDFF; + vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_BROKEN_TRAIN; return false; } @@ -3728,8 +3697,7 @@ static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ri } invalidate_sprite_2((rct_sprite *) peep); - int out = peep_update_action(&x, &y, &tmp_distance, peep); - if (out == 0) { + if (!peep_update_action(&x, &y, &tmp_distance, peep)) { return true; } @@ -3755,7 +3723,7 @@ static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) { invalidate_sprite_2((rct_sprite *) peep); } - if (peep->action == 0xFF) { + if (peep->action == PEEP_ACTION_NONE_2) { return true; } @@ -3785,10 +3753,6 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri rct_xy_element input; input.x = (stationPosition & 0xFF) * 32; input.y = (stationPosition >> 8) * 32; - - char buffer[256]; - format_string(buffer, ride->name, &ride->name_arguments); - log_info("%s", buffer); input.element = map_get_track_element_at_from_ride(input.x, input.y, stationZ, peep->current_ride); track_begin_end trackBeginEnd; @@ -3811,7 +3775,7 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri uint16 destinationX = input.x + TileDirectionDelta[direction].x + 16; uint16 destinationY = input.y + TileDirectionDelta[direction].y + 16; - rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction * 2]; + rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction]; destinationX -= offset.x; if (offset.x == 0) { @@ -3847,7 +3811,7 @@ static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_r sint16 tmp_x, tmp_y, tmp_xy_distance; if (!firstRun) { - if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 & RIDE_TYPE_FLAG_15)) { + if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3 | RIDE_TYPE_FLAG_15)) { return true; } @@ -3861,7 +3825,7 @@ static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_r invalidate_sprite_2((rct_sprite *) peep); } - if (peep->action == 0xFF) { + if (peep->action == PEEP_ACTION_NONE_2) { return true; } @@ -3887,7 +3851,7 @@ static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_r invalidate_sprite_2((rct_sprite *) peep); } - if (peep->action == 0xFF) { + if (peep->action == PEEP_ACTION_NONE_2) { return true; } @@ -4049,7 +4013,7 @@ static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_r */ static void sub_6B7588(int rideIndex) { rct_ride *ride = get_ride(rideIndex); - ride->lifecycle_flags &= 0xFFFFFEFF; + ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION; ride->reliability += ((100 - ride->reliability) >> 2) * (scenario_rand() & 0xFF); ride->last_inspection = 0; diff --git a/src/peep/peep.h b/src/peep/peep.h index bcb7a8cf4f..2c13af41b3 100644 --- a/src/peep/peep.h +++ b/src/peep/peep.h @@ -231,6 +231,7 @@ enum PEEP_ACTION_EVENTS { PEEP_ACTION_STAFF_FIX = 15, PEEP_ACTION_STAFF_FIX_2 = 16, PEEP_ACTION_STAFF_FIX_GROUND = 17, + PEEP_ACTION_STAFF_FIX_3 = 18, PEEP_ACTION_STAFF_WATERING = 19, PEEP_ACTION_JOY = 20, PEEP_ACTION_READ_MAP = 21, diff --git a/src/ride/ride.c b/src/ride/ride.c index 00aa7d279e..c28ee14fac 100644 --- a/src/ride/ride.c +++ b/src/ride/ride.c @@ -8138,3 +8138,18 @@ const uint32 ride_customers_in_last_5_minutes(const rct_ride *ride) { + ride->num_customers[9]; return sum; } + +rct_vehicle *ride_get_broken_vehicle(rct_ride *ride) { + uint16 vehicleIndex = ride->vehicles[ride->broken_vehicle]; + + if (vehicleIndex == 0xFFFF) { + return NULL; + } + + rct_vehicle *vehicle = GET_VEHICLE(vehicleIndex); + for (uint8 i = 0; i < ride->broken_car; i++) { + vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); + } + + return vehicle; +} diff --git a/src/ride/ride.h b/src/ride/ride.h index 4bbd506d33..ff17c16730 100644 --- a/src/ride/ride.h +++ b/src/ride/ride.h @@ -1046,4 +1046,5 @@ void window_ride_construction_mouseup_demolish_next_piece(int x, int y, int z, i const uint32 ride_customers_per_hour(const rct_ride *ride); const uint32 ride_customers_in_last_5_minutes(const rct_ride *ride); +rct_vehicle * ride_get_broken_vehicle(rct_ride *ride); #endif From 27cdf114c95d0d729dbdb2c7e9c03f909c3f2b80 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Sat, 13 Feb 2016 10:24:48 +0100 Subject: [PATCH 08/11] Only use high bits for calculating reliability --- src/peep/peep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 395e44b597..3f1168c9e5 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -4015,7 +4015,7 @@ static void sub_6B7588(int rideIndex) { rct_ride *ride = get_ride(rideIndex); ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION; - ride->reliability += ((100 - ride->reliability) >> 2) * (scenario_rand() & 0xFF); + ride->reliability += ((100 - (ride->reliability >> 8)) >> 2) * (scenario_rand() & 0xFF); ride->last_inspection = 0; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST; } From 564a26d006740b10ed79433e92aa0ed7432ea6d3 Mon Sep 17 00:00:00 2001 From: duncanspumpkin Date: Sat, 13 Feb 2016 12:58:17 +0100 Subject: [PATCH 09/11] Invalidate maintenance tab after fixing ride --- src/ride/ride.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ride/ride.c b/src/ride/ride.c index c28ee14fac..a254f96f19 100644 --- a/src/ride/ride.c +++ b/src/ride/ride.c @@ -7115,7 +7115,7 @@ void ride_fix_breakdown(int rideIndex, int reliabilityIncreaseFactor) ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BREAKDOWN_PENDING; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BROKEN_DOWN; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION; - ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER; + ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST | RIDE_INVALIDATE_RIDE_MAINTENANCE; if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK) { rct_vehicle *vehicle; From 5ab655cffc71962f445e03d7fc85e3f44583c5c9 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Sat, 13 Feb 2016 14:54:27 +0100 Subject: [PATCH 10/11] Use enum for track types --- src/peep/peep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 3f1168c9e5..16471bf875 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -3758,7 +3758,7 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri track_begin_end trackBeginEnd; while (track_block_get_previous(input.x, input.y, input.element, &trackBeginEnd)) { uint8 trackType = trackBeginEnd.begin_element->properties.track.type; - if (trackType == 2 || trackType == 3 || trackType == 1) { + if (trackType == TRACK_ELEM_BEGIN_STATION || trackType == TRACK_ELEM_MIDDLE_STATION || trackType == TRACK_ELEM_END_STATION) { input.x = trackBeginEnd.begin_x; input.y = trackBeginEnd.begin_y; input.element = trackBeginEnd.begin_element; From 3f7044c09ce2a031921d6ecdf16dd77de18bbfe6 Mon Sep 17 00:00:00 2001 From: Marijn van der Werf Date: Sat, 13 Feb 2016 15:07:57 +0100 Subject: [PATCH 11/11] Decrease destination offset --- src/peep/peep.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/peep/peep.c b/src/peep/peep.c index 16471bf875..c52ebe9b46 100644 --- a/src/peep/peep.c +++ b/src/peep/peep.c @@ -3771,10 +3771,10 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri } // loc_6C12ED: - uint8 direction = RCT2_GLOBAL(0xF43914, uint32); - uint16 destinationX = input.x + TileDirectionDelta[direction].x + 16; - uint16 destinationY = input.y + TileDirectionDelta[direction].y + 16; + uint16 destinationX = input.x + 16; + uint16 destinationY = input.y + 16; + uint8 direction = RCT2_GLOBAL(0xF43914, uint32); rct_xy16 offset = RCT2_ADDRESS(0x992A3C, rct_xy16)[direction]; destinationX -= offset.x;