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

Close #12388, refactor PeepState to use strong enum (#12927) 

* Close #12388, refactor:PeepState to use strong enum

* refactor: refactored file PlayTests.cpp

* refactor: change PEEP_STATE_ to PeepState:: and camel case after merging

chore: code reformatting
This commit is contained in:
Łukasz Pękalski 2020-09-28 20:51:49 +02:00 committed by GitHub
parent d27e14f45b
commit d1cd2e08b5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 264 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -711,7 +711,7 @@ void window_guest_viewport_init(rct_window* w)
w->viewport_focus_coordinates.z = focus.coordinate.z;
w->viewport_focus_coordinates.rotation = focus.coordinate.rotation;
if (peep->State != PEEP_STATE_PICKED && w->viewport == nullptr)
if (peep->State != PeepState::Picked && w->viewport == nullptr)
{
auto view_widget = &w->widgets[WIDX_VIEWPORT];
auto screenPos = ScreenCoordsXY{ view_widget->left + 1 + w->windowPos.x, view_widget->top + 1 + w->windowPos.y };

6
src/openrct2-ui/windows/Staff.cpp
View File

@ -288,7 +288,7 @@ rct_window* window_staff_open(Peep* peep)
window_init_scroll_widgets(w);
window_staff_viewport_init(w);
if (peep->State == PEEP_STATE_PICKED)
if (peep->State == PeepState::Picked)
window_event_mouse_up_call(w, WIDX_CHECKBOX_3);
return w;
@ -1339,7 +1339,7 @@ void window_staff_viewport_init(rct_window* w)
return;
}
if (peep->State == PEEP_STATE_PICKED)
if (peep->State == PeepState::Picked)
{
focus.sprite_id = SPRITE_INDEX_NULL;
}
@ -1375,7 +1375,7 @@ void window_staff_viewport_init(rct_window* w)
w->viewport_focus_sprite.type = focus.type;
w->viewport_focus_sprite.rotation = focus.rotation;
if (peep->State != PEEP_STATE_PICKED)
if (peep->State != PeepState::Picked)
{
if (!(w->viewport))
{

2
src/openrct2/actions/RideDemolishAction.hpp
View File

@ -160,7 +160,7 @@ private:
// clear ride from potentially being in RidesBeenOn
peep->RidesBeenOn[ride_id_offset] &= ~(1 << ride_id_bit);
if (peep->State == PEEP_STATE_WATCHING)
if (peep->State == PeepState::Watching)
{
if (peep->CurrentRide == _rideIndex)
{

12
src/openrct2/actions/StaffHireNewAction.hpp
View File

@ -221,7 +221,7 @@ private:
else
{
// NOTE: This state is required for the window to act.
newPeep->State = PEEP_STATE_PICKED;
newPeep->State = PeepState::Picked;
newPeep->MoveTo({ newPeep->x, newPeep->y, newPeep->z });
}
@ -260,7 +260,7 @@ private:
void AutoPositionNewStaff(Peep * newPeep) const
{
// Find a location to place new staff member
newPeep->State = PEEP_STATE_FALLING;
newPeep->State = PeepState::Falling;
uint32_t count = 0;
PathElement* guest_tile = nullptr;
@ -269,7 +269,7 @@ private:
{
for (auto guest : EntityList<Guest>(EntityListId::Peep))
{
if (guest->State == PEEP_STATE_WALKING)
if (guest->State == PeepState::Walking)
{
// Check the walking guest's tile. Only count them if they're on a path tile.
guest_tile = map_get_path_element_at(TileCoordsXYZ{ guest->NextLoc });
@ -288,7 +288,7 @@ private:
for (auto guest : EntityList<Guest>(EntityListId::Peep))
{
if (guest->State == PEEP_STATE_WALKING)
if (guest->State == PeepState::Walking)
{
guest_tile = map_get_path_element_at(TileCoordsXYZ{ guest->NextLoc });
if (guest_tile != nullptr)
@ -312,7 +312,7 @@ private:
else
{
// User must pick a location
newPeep->State = PEEP_STATE_PICKED;
newPeep->State = PeepState::Picked;
newLocation.x = newPeep->x;
newLocation.y = newPeep->y;
newLocation.z = newPeep->z;
@ -334,7 +334,7 @@ private:
else
{
// User must pick a location
newPeep->State = PEEP_STATE_PICKED;
newPeep->State = PeepState::Picked;
newLocation.x = newPeep->x;
newLocation.y = newPeep->y;
newLocation.z = newPeep->z;

8
src/openrct2/interface/Viewport.cpp
View File

@ -692,7 +692,7 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
focus.type = VIEWPORT_FOCUS_TYPE_SPRITE;
focus.sprite.sprite_id = peep->sprite_index;
if (peep->State == PEEP_STATE_PICKED)
if (peep->State == PeepState::Picked)
{
focus.sprite.sprite_id = SPRITE_INDEX_NULL;
window->viewport_smart_follow_sprite = SPRITE_INDEX_NULL;
@ -702,8 +702,8 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
else
{
bool overallFocus = true;
if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE
|| (peep->State == PEEP_STATE_LEAVING_RIDE && peep->x == LOCATION_NULL))
if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide
|| (peep->State == PeepState::LeavingRide && peep->x == LOCATION_NULL))
{
auto ride = get_ride(peep->CurrentRide);
if (ride != nullptr && (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
@ -752,7 +752,7 @@ void viewport_update_smart_staff_follow(rct_window* window, Peep* peep)
focus.sprite_id = window->viewport_smart_follow_sprite;
if (peep->State == PEEP_STATE_PICKED)
if (peep->State == PeepState::Picked)
{
// focus.sprite.sprite_id = SPRITE_INDEX_NULL;
window->viewport_smart_follow_sprite = SPRITE_INDEX_NULL;

2
src/openrct2/management/NewsItem.cpp
View File

@ -228,7 +228,7 @@ std::optional<CoordsXYZ> News::GetSubjectLocation(News::ItemType type, int32_t s
if (subjectLoc->x != LOCATION_NULL)
break;
if (peep->State != PEEP_STATE_ON_RIDE && peep->State != PEEP_STATE_ENTERING_RIDE)
if (peep->State != PeepState::OnRide && peep->State != PeepState::EnteringRide)
{
subjectLoc = std::nullopt;
break;

114
src/openrct2/peep/Guest.cpp
View File

@ -471,7 +471,7 @@ void Guest::MakePassingPeepsSick(Guest* passingPeep)
{
if (this == passingPeep)
return;
if (passingPeep->State != PEEP_STATE_WALKING)
if (passingPeep->State != PeepState::Walking)
return;
if (passingPeep->Action == PEEP_ACTION_NONE_1 || passingPeep->Action == PEEP_ACTION_NONE_2)
@ -723,7 +723,7 @@ void Guest::loc_68F9F3()
Toilet--;
}
if (State == PEEP_STATE_WALKING && NauseaTarget >= 128)
if (State == PeepState::Walking && NauseaTarget >= 128)
{
if ((scenario_rand() & 0xFF) <= static_cast<uint8_t>((Nausea - 128) / 2))
{
@ -746,7 +746,7 @@ void Guest::loc_68FA89()
TimeToConsume += 3;
}
if (TimeToConsume != 0 && State != PEEP_STATE_ON_RIDE)
if (TimeToConsume != 0 && State != PeepState::OnRide)
{
TimeToConsume = std::max(TimeToConsume - 3, 0);
@ -888,7 +888,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
if (PeepFlags & PEEP_FLAGS_EXPLODE && x != LOCATION_NULL)
{
if (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING)
if (State == PeepState::Walking || State == PeepState::Sitting)
{
audio_play_sound_at_location(SoundId::Crash, { x, y, z });
@ -931,7 +931,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
if (Angriness != 0)
Angriness--;
if (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING)
if (State == PeepState::Walking || State == PeepState::Sitting)
{
SurroundingsThoughtTimeout++;
if (SurroundingsThoughtTimeout >= 18)
@ -952,7 +952,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
UpdateSpriteType();
if (State == PEEP_STATE_ON_RIDE || State == PEEP_STATE_ENTERING_RIDE)
if (State == PeepState::OnRide || State == PeepState::EnteringRide)
{
GuestTimeOnRide = std::min(255, GuestTimeOnRide + 1);
@ -980,7 +980,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
}
}
if (State == PEEP_STATE_WALKING && !OutsideOfPark && !(PeepFlags & PEEP_FLAGS_LEAVING_PARK) && GuestNumRides == 0
if (State == PeepState::Walking && !OutsideOfPark && !(PeepFlags & PEEP_FLAGS_LEAVING_PARK) && GuestNumRides == 0
&& GuestHeadingToRideId == RIDE_ID_NULL)
{
uint32_t time_duration = gScenarioTicks - TimeInPark;
@ -1015,7 +1015,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
* is executed to once every second time the encompassing
* conditional executes. */
if (!OutsideOfPark && (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING))
if (!OutsideOfPark && (State == PeepState::Walking || State == PeepState::Sitting))
{
uint8_t num_thoughts = 0;
PeepThoughtType possible_thoughts[5];
@ -1105,14 +1105,14 @@ void Guest::Tick128UpdateGuest(int32_t index)
switch (State)
{
case PEEP_STATE_WALKING:
case PEEP_STATE_LEAVING_PARK:
case PEEP_STATE_ENTERING_PARK:
case PeepState::Walking:
case PeepState::LeavingPark:
case PeepState::EnteringPark:
peep_decide_whether_to_leave_park(this);
peep_update_hunger(this);
break;
case PEEP_STATE_SITTING:
case PeepState::Sitting:
if (EnergyTarget <= 135)
EnergyTarget += 5;
@ -1131,7 +1131,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
peep_update_hunger(this);
break;
case PEEP_STATE_QUEUING:
case PeepState::Queuing:
if (TimeInQueue >= 2000)
{
/* Peep happiness is affected once the peep has been waiting
@ -1181,7 +1181,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
}
peep_update_hunger(this);
break;
case PEEP_STATE_ENTERING_RIDE:
case PeepState::EnteringRide:
if (SubState == 17 || SubState == 15)
{
peep_decide_whether_to_leave_park(this);
@ -1212,7 +1212,7 @@ void Guest::TryGetUpFromSitting()
if (TimeToSitdown)
return;
SetState(PEEP_STATE_WALKING);
SetState(PeepState::Walking);
// Set destination to the centre of the tile.
DestinationX = (x & 0xFFE0) + 16;
@ -1267,7 +1267,7 @@ void Guest::UpdateSitting()
if ((PeepFlags & PEEP_FLAGS_LEAVING_PARK))
{
SetState(PEEP_STATE_WALKING);
SetState(PeepState::Walking);
// Set destination to the centre of the tile
DestinationX = (x & 0xFFE0) + 16;
@ -1858,7 +1858,7 @@ bool Guest::HasFood() const
*/
void Guest::PickRideToGoOn()
{
if (State != PEEP_STATE_WALKING)
if (State != PeepState::Walking)
return;
if (GuestHeadingToRideId != RIDE_ID_NULL)
return;
@ -2557,7 +2557,7 @@ void Guest::GoToRideEntrance(Ride* ride)
DestinationY = location.y;
DestinationTolerance = 2;
SetState(PEEP_STATE_ENTERING_RIDE);
SetState(PeepState::EnteringRide);
SubState = PEEP_RIDE_IN_ENTRANCE;
RejoinQueueTimeout = 0;
@ -2640,7 +2640,7 @@ static void peep_update_ride_at_entrance_try_leave(Guest* peep)
if (peep->DestinationTolerance == 0)
{
peep->RemoveFromQueue();
peep->SetState(PEEP_STATE_FALLING);
peep->SetState(PeepState::Falling);
}
}
@ -3151,7 +3151,7 @@ static void peep_leave_park(Peep* peep)
template<typename T> static void peep_head_for_nearest_ride(Guest* peep, bool considerOnlyCloseRides, T predicate)
{
if (peep->State != PEEP_STATE_SITTING && peep->State != PEEP_STATE_WATCHING && peep->State != PEEP_STATE_WALKING)
if (peep->State != PeepState::Sitting && peep->State != PeepState::Watching && peep->State != PeepState::Walking)
{
return;
}
@ -3366,7 +3366,7 @@ void Guest::UpdateBuying()
auto ride = get_ride(CurrentRide);
if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
@ -3392,7 +3392,7 @@ void Guest::UpdateBuying()
DestinationY = NextLoc.y + 16;
PeepDirection = direction_reverse(PeepDirection);
SetState(PEEP_STATE_WALKING);
SetState(PeepState::Walking);
return;
}
@ -3933,7 +3933,7 @@ static void peep_update_ride_no_free_vehicle_rejoin_queue(Peep* peep, Ride* ride
peep->DestinationY = y;
peep->DestinationTolerance = 2;
peep->SetState(PEEP_STATE_QUEUING_FRONT);
peep->SetState(PeepState::QueuingFront);
peep->SubState = PEEP_RIDE_AT_ENTRANCE;
ride->QueueInsertGuestAtFront(peep->CurrentRideStation, peep);
@ -4090,7 +4090,7 @@ void Guest::UpdateRideEnterVehicle()
vehicle->mass += seatedGuest->Mass;
seatedGuest->MoveTo({ LOCATION_NULL, 0, 0 });
seatedGuest->SetState(PEEP_STATE_ON_RIDE);
seatedGuest->SetState(PeepState::OnRide);
seatedGuest->GuestTimeOnRide = 0;
seatedGuest->SubState = PEEP_RIDE_ON_RIDE;
seatedGuest->OnEnterRide(CurrentRide);
@ -4105,7 +4105,7 @@ void Guest::UpdateRideEnterVehicle()
MoveTo({ LOCATION_NULL, 0, 0 });
SetState(PEEP_STATE_ON_RIDE);
SetState(PeepState::OnRide);
GuestTimeOnRide = 0;
SubState = PEEP_RIDE_ON_RIDE;
@ -5020,7 +5020,7 @@ void Guest::UpdateRideLeaveExit()
}
InteractionRideIndex = RIDE_ID_NULL;
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
CoordsXY targetLoc = { x, y };
@ -5132,8 +5132,8 @@ void Guest::UpdateRideShopLeave()
return;
}
//#11758 Previously SetState(PEEP_STATE_WALKING) caused Peeps to double-back to exit point of shop
SetState(PEEP_STATE_FALLING);
//#11758 Previously SetState(PeepState::Walking) caused Peeps to double-back to exit point of shop
SetState(PeepState::Falling);
auto ride = get_ride(CurrentRide);
if (ride != nullptr)
@ -5148,37 +5148,37 @@ void Guest::UpdateGuest()
{
switch (State)
{
case PEEP_STATE_QUEUING_FRONT:
case PeepState::QueuingFront:
UpdateRide();
break;
case PEEP_STATE_LEAVING_RIDE:
case PeepState::LeavingRide:
UpdateRide();
break;
case PEEP_STATE_WALKING:
case PeepState::Walking:
UpdateWalking();
break;
case PEEP_STATE_QUEUING:
case PeepState::Queuing:
UpdateQueuing();
break;
case PEEP_STATE_ENTERING_RIDE:
case PeepState::EnteringRide:
UpdateRide();
break;
case PEEP_STATE_SITTING:
case PeepState::Sitting:
UpdateSitting();
break;
case PEEP_STATE_ENTERING_PARK:
case PeepState::EnteringPark:
UpdateEnteringPark();
break;
case PEEP_STATE_LEAVING_PARK:
case PeepState::LeavingPark:
UpdateLeavingPark();
break;
case PEEP_STATE_BUYING:
case PeepState::Buying:
UpdateBuying();
break;
case PEEP_STATE_WATCHING:
case PeepState::Watching:
UpdateWatching();
break;
case PEEP_STATE_USING_BIN:
case PeepState::UsingBin:
UpdateUsingBin();
break;
default:
@ -5408,7 +5408,7 @@ void Guest::UpdateWalking()
if (water_height > 0)
{
MoveTo({ x, y, water_height });
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
}
@ -5426,7 +5426,7 @@ void Guest::UpdateWalking()
peep_update_walking_break_scenery(this);
if (State != PEEP_STATE_WALKING)
if (State != PeepState::Walking)
return;
if (PeepFlags & PEEP_FLAGS_LEAVING_PARK)
@ -5499,7 +5499,7 @@ void Guest::UpdateWalking()
// Check if there is a peep watching (and if there is place for us)
for (auto peep : EntityTileList<Peep>({ x, y }))
{
if (peep->State != PEEP_STATE_WATCHING)
if (peep->State != PeepState::Watching)
continue;
if (z != peep->z)
@ -5523,7 +5523,7 @@ void Guest::UpdateWalking()
CurrentSeat = ride_seat_to_view;
Var37 = chosen_edge | (chosen_position << 2);
SetState(PEEP_STATE_WATCHING);
SetState(PeepState::Watching);
SubState = 0;
int32_t destX = (x & 0xFFE0) + _WatchingPositionOffsets[Var37 & 0x1F].x;
@ -5558,7 +5558,7 @@ void Guest::UpdateQueuing()
if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
{
RemoveFromQueue();
SetState(PEEP_STATE_1);
SetState(PeepState::One);
return;
}
@ -5583,7 +5583,7 @@ void Guest::UpdateQueuing()
{
// Happens every time peep goes onto ride.
DestinationTolerance = 0;
SetState(PEEP_STATE_QUEUING_FRONT);
SetState(PeepState::QueuingFront);
SubState = PEEP_RIDE_AT_ENTRANCE;
return;
}
@ -5592,7 +5592,7 @@ void Guest::UpdateQueuing()
sprite_direction ^= (1 << 4);
Invalidate();
RemoveFromQueue();
SetState(PEEP_STATE_1);
SetState(PeepState::One);
return;
}
@ -5664,7 +5664,7 @@ void Guest::UpdateQueuing()
sprite_direction ^= (1 << 4);
Invalidate();
RemoveFromQueue();
SetState(PEEP_STATE_1);
SetState(PeepState::One);
}
}
@ -5689,7 +5689,7 @@ void Guest::UpdateEnteringPark()
MoveTo({ *loc, z });
return;
}
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
OutsideOfPark = false;
TimeInPark = gScenarioTicks;
@ -5821,7 +5821,7 @@ void Guest::UpdateWatching()
if (TimeToStand != 0)
return;
SetState(PEEP_STATE_WALKING);
SetState(PeepState::Walking);
UpdateSpriteType();
// Send peep to the centre of current tile.
DestinationX = (x & 0xFFE0) + 16;
@ -6079,7 +6079,7 @@ bool Guest::UpdateWalkingFindBench()
// Check if there is no peep sitting in chosen_edge
for (auto peep : EntityTileList<Peep>({ x, y }))
{
if (peep->State != PEEP_STATE_SITTING)
if (peep->State != PeepState::Sitting)
continue;
if (z != peep->z)
@ -6103,7 +6103,7 @@ bool Guest::UpdateWalkingFindBench()
Var37 = ((free_edge & 1) << 2) | chosen_edge;
SetState(PEEP_STATE_SITTING);
SetState(PeepState::Sitting);
SittingSubState = PeepSittingSubState::TryingToSit;
@ -6188,7 +6188,7 @@ bool Guest::UpdateWalkingFindBin()
peep->Var37 = chosen_edge;
peep->SetState(PEEP_STATE_USING_BIN);
peep->SetState(PeepState::UsingBin);
peep->SubState = PEEP_USING_BIN_WALKING_TO_BIN;
int32_t binX = (peep->x & 0xFFE0) + BinUseOffsets[peep->Var37 & 0x3].x;
@ -6216,7 +6216,7 @@ static void peep_update_walking_break_scenery(Peep* peep)
return;
if (peep->Energy < 85)
return;
if (peep->State != PEEP_STATE_WALKING)
if (peep->State != PeepState::Walking)
return;
if ((peep->LitterCount & 0xC0) != 0xC0 && (peep->DisgustingCount & 0xC0) != 0xC0)
@ -6266,7 +6266,7 @@ static void peep_update_walking_break_scenery(Peep* peep)
// Check if a peep is already sitting on the bench. If so, do not vandalise it.
for (auto peep2 : EntityTileList<Peep>({ peep->x, peep->y }))
{
if ((peep2->State != PEEP_STATE_SITTING) || (peep->z != peep2->z))
if ((peep2->State != PeepState::Sitting) || (peep->z != peep2->z))
{
continue;
}
@ -6780,13 +6780,13 @@ void Guest::SetSpriteType(PeepSpriteType new_sprite_type)
ActionSpriteType = PEEP_ACTION_SPRITE_TYPE_INVALID;
UpdateCurrentActionSpriteType();
if (State == PEEP_STATE_SITTING)
if (State == PeepState::Sitting)
{
Action = PEEP_ACTION_NONE_1;
NextActionSpriteType = PEEP_ACTION_SPRITE_TYPE_SITTING_IDLE;
SwitchNextActionSpriteType();
}
if (State == PEEP_STATE_WATCHING)
if (State == PeepState::Watching)
{
Action = PEEP_ACTION_NONE_1;
NextActionSpriteType = PEEP_ACTION_SPRITE_TYPE_WATCH_RIDE;
@ -6903,7 +6903,7 @@ void Guest::UpdateSpriteType()
}
}
if (State == PEEP_STATE_WATCHING && StandingFlags & (1 << 1))
if (State == PeepState::Watching && StandingFlags & (1 << 1))
{
SetSpriteType(PEEP_SPRITE_TYPE_WATCHING);
return;

6
src/openrct2/peep/GuestPathfinding.cpp
View File

@ -135,7 +135,7 @@ static int32_t peep_move_one_tile(Direction direction, Peep* peep)
peep->DestinationX = newTile.x;
peep->DestinationY = newTile.y;
peep->DestinationTolerance = 2;
if (peep->State != PEEP_STATE_QUEUING)
if (peep->State != PeepState::Queuing)
{
peep->DestinationTolerance = (scenario_rand() & 7) + 2;
}
@ -2045,9 +2045,9 @@ int32_t guest_path_finding(Guest* peep)
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
switch (peep->State)
{
case PEEP_STATE_ENTERING_PARK:
case PeepState::EnteringPark:
return guest_path_find_entering_park(peep, edges);
case PEEP_STATE_LEAVING_PARK:
case PeepState::LeavingPark:
return guest_path_find_leaving_park(peep, edges);
default:
return guest_path_find_aimless(peep, edges);

188
src/openrct2/peep/Peep.cpp
View File

@ -468,7 +468,7 @@ bool Peep::CheckForPath()
} while (!(tile_element++)->IsLastForTile());
// Found no suitable path
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return false;
}
@ -534,7 +534,7 @@ void Peep::SwitchToSpecialSprite(uint8_t special_sprite_id)
void Peep::StateReset()
{
SetState(PEEP_STATE_1);
SetState(PeepState::One);
SwitchToSpecialSprite(0);
}
@ -653,7 +653,7 @@ std::optional<CoordsXY> Peep::UpdateAction(int16_t& xy_distance)
*/
void peep_decrement_num_riders(Peep* peep)
{
if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
{
auto ride = get_ride(peep->CurrentRide);
if (ride != nullptr)
@ -677,7 +677,7 @@ void peep_window_state_update(Peep* peep)
if (peep->AssignedPeepType == PeepType::Guest)
{
if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
{
auto ride = get_ride(peep->CurrentRide);
if (ride != nullptr)
@ -705,20 +705,20 @@ void Peep::Pickup()
guest->RemoveFromRide();
}
MoveTo({ LOCATION_NULL, y, z });
SetState(PEEP_STATE_PICKED);
SetState(PeepState::Picked);
SubState = 0;
}
void Peep::PickupAbort(int32_t old_x)
{
if (State != PEEP_STATE_PICKED)
if (State != PeepState::Picked)
return;
MoveTo({ old_x, y, z + 8 });
if (x != LOCATION_NULL)
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
Action = PEEP_ACTION_NONE_2;
SpecialSprite = 0;
ActionSpriteImageOffset = 0;
@ -768,7 +768,7 @@ std::unique_ptr<GameActionResult> Peep::Place(const TileCoordsXYZ& location, boo
if (apply)
{
MoveTo(destination);
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
Action = PEEP_ACTION_NONE_2;
SpecialSprite = 0;
ActionSpriteImageOffset = 0;
@ -838,7 +838,7 @@ void Peep::Remove()
auto intent = Intent(INTENT_ACTION_UPDATE_GUEST_COUNT);
context_broadcast_intent(&intent);
}
if (State == PEEP_STATE_ENTERING_PARK)
if (State == PeepState::EnteringPark)
{
decrement_guests_heading_for_park();
}
@ -961,7 +961,7 @@ void Peep::UpdateFalling()
{
SetNextFlags(saved_map->AsPath()->GetSlopeDirection(), saved_map->AsPath()->IsSloped(), false);
}
SetState(PEEP_STATE_1);
SetState(PeepState::One);
}
/**
@ -975,11 +975,11 @@ void Peep::Update1()
if (AssignedPeepType == PeepType::Guest)
{
SetState(PEEP_STATE_WALKING);
SetState(PeepState::Walking);
}
else
{
SetState(PEEP_STATE_PATROLLING);
SetState(PeepState::Patrolling);
}
DestinationX = x;
@ -1088,14 +1088,14 @@ void Peep::Update()
// Walking speed logic
uint32_t stepsToTake = Energy;
if (stepsToTake < 95 && State == PEEP_STATE_QUEUING)
if (stepsToTake < 95 && State == PeepState::Queuing)
stepsToTake = 95;
if ((PeepFlags & PEEP_FLAGS_SLOW_WALK) && State != PEEP_STATE_QUEUING)
if ((PeepFlags & PEEP_FLAGS_SLOW_WALK) && State != PeepState::Queuing)
stepsToTake /= 2;
if (Action == PEEP_ACTION_NONE_2 && (GetNextIsSloped()))
{
stepsToTake /= 2;
if (State == PEEP_STATE_QUEUING)
if (State == PeepState::Queuing)
stepsToTake += stepsToTake / 2;
}
@ -1114,16 +1114,16 @@ void Peep::Update()
// loc_68FD2F
switch (State)
{
case PEEP_STATE_FALLING:
case PeepState::Falling:
UpdateFalling();
break;
case PEEP_STATE_1:
case PeepState::One:
Update1();
break;
case PEEP_STATE_ON_RIDE:
case PeepState::OnRide:
// No action
break;
case PEEP_STATE_PICKED:
case PeepState::Picked:
UpdatePicked();
break;
default:
@ -1353,7 +1353,7 @@ void peep_update_crowd_noise()
if (viewport->viewPos.y + viewport->view_height < peep->sprite_top)
continue;
visiblePeeps += peep->State == PEEP_STATE_QUEUING ? 1 : 2;
visiblePeeps += peep->State == PeepState::Queuing ? 1 : 2;
}
// This function doesn't account for the fact that the screen might be so big that 100 peeps could potentially be very
@ -1412,7 +1412,7 @@ void peep_applause()
peep_release_balloon(peep, peep->z + 9);
// Clap
if ((peep->State == PEEP_STATE_WALKING || peep->State == PEEP_STATE_QUEUING) && peep->Action >= 254)
if ((peep->State == PeepState::Walking || peep->State == PeepState::Queuing) && peep->Action >= 254)
{
peep->Action = PEEP_ACTION_CLAP;
peep->ActionFrame = 0;
@ -1433,7 +1433,7 @@ void peep_update_days_in_queue()
{
for (auto peep : EntityList<Guest>(EntityListId::Peep))
{
if (!peep->OutsideOfPark && peep->State == PEEP_STATE_QUEUING)
if (!peep->OutsideOfPark && peep->State == PeepState::Queuing)
{
if (peep->DaysInQueue < 255)
{
@ -1580,7 +1580,7 @@ Peep* Peep::Generate(const CoordsXYZ& coords)
peep->sprite_identifier = SPRITE_IDENTIFIER_PEEP;
peep->SpriteType = PEEP_SPRITE_TYPE_NORMAL;
peep->OutsideOfPark = true;
peep->State = PEEP_STATE_FALLING;
peep->State = PeepState::Falling;
peep->Action = PEEP_ACTION_NONE_2;
peep->SpecialSprite = 0;
peep->ActionSpriteImageOffset = 0;
@ -1747,15 +1747,15 @@ void Peep::FormatActionTo(Formatter& ft) const
{
switch (State)
{
case PEEP_STATE_FALLING:
case PeepState::Falling:
ft.Add<rct_string_id>(Action == PEEP_ACTION_DROWNING ? STR_DROWNING : STR_WALKING);
break;
case PEEP_STATE_1:
case PeepState::One:
ft.Add<rct_string_id>(STR_WALKING);
break;
case PEEP_STATE_ON_RIDE:
case PEEP_STATE_LEAVING_RIDE:
case PEEP_STATE_ENTERING_RIDE:
case PeepState::OnRide:
case PeepState::LeavingRide:
case PeepState::EnteringRide:
{
auto ride = get_ride(CurrentRide);
if (ride != nullptr)
@ -1769,7 +1769,7 @@ void Peep::FormatActionTo(Formatter& ft) const
}
break;
}
case PEEP_STATE_BUYING:
case PeepState::Buying:
{
ft.Add<rct_string_id>(STR_AT_RIDE);
auto ride = get_ride(CurrentRide);
@ -1783,8 +1783,8 @@ void Peep::FormatActionTo(Formatter& ft) const
}
break;
}
case PEEP_STATE_WALKING:
case PEEP_STATE_USING_BIN:
case PeepState::Walking:
case PeepState::UsingBin:
if (GuestHeadingToRideId != RIDE_ID_NULL)
{
auto ride = get_ride(GuestHeadingToRideId);
@ -1799,8 +1799,8 @@ void Peep::FormatActionTo(Formatter& ft) const
ft.Add<rct_string_id>((PeepFlags & PEEP_FLAGS_LEAVING_PARK) ? STR_LEAVING_PARK : STR_WALKING);
}
break;
case PEEP_STATE_QUEUING_FRONT:
case PEEP_STATE_QUEUING:
case PeepState::QueuingFront:
case PeepState::Queuing:
{
auto ride = get_ride(CurrentRide);
if (ride != nullptr)
@ -1810,10 +1810,10 @@ void Peep::FormatActionTo(Formatter& ft) const
}
break;
}
case PEEP_STATE_SITTING:
case PeepState::Sitting:
ft.Add<rct_string_id>(STR_SITTING);
break;
case PEEP_STATE_WATCHING:
case PeepState::Watching:
if (CurrentRide != RIDE_ID_NULL)
{
auto ride = get_ride(CurrentRide);
@ -1828,27 +1828,27 @@ void Peep::FormatActionTo(Formatter& ft) const
ft.Add<rct_string_id>((StandingFlags & 0x1) ? STR_WATCHING_NEW_RIDE_BEING_CONSTRUCTED : STR_LOOKING_AT_SCENERY);
}
break;
case PEEP_STATE_PICKED:
case PeepState::Picked:
ft.Add<rct_string_id>(STR_SELECT_LOCATION);
break;
case PEEP_STATE_PATROLLING:
case PEEP_STATE_ENTERING_PARK:
case PEEP_STATE_LEAVING_PARK:
case PeepState::Patrolling:
case PeepState::EnteringPark:
case PeepState::LeavingPark:
ft.Add<rct_string_id>(STR_WALKING);
break;
case PEEP_STATE_MOWING:
case PeepState::Mowing:
ft.Add<rct_string_id>(STR_MOWING_GRASS);
break;
case PEEP_STATE_SWEEPING:
case PeepState::Sweeping:
ft.Add<rct_string_id>(STR_SWEEPING_FOOTPATH);
break;
case PEEP_STATE_WATERING:
case PeepState::Watering:
ft.Add<rct_string_id>(STR_WATERING_GARDENS);
break;
case PEEP_STATE_EMPTYING_BIN:
case PeepState::EmptyingBin:
ft.Add<rct_string_id>(STR_EMPTYING_LITTER_BIN);
break;
case PEEP_STATE_ANSWERING:
case PeepState::Answering:
if (SubState == 0)
{
ft.Add<rct_string_id>(STR_WALKING);
@ -1871,7 +1871,7 @@ void Peep::FormatActionTo(Formatter& ft) const
}
}
break;
case PEEP_STATE_FIXING:
case PeepState::Fixing:
{
ft.Add<rct_string_id>(STR_FIXING_RIDE);
auto ride = get_ride(CurrentRide);
@ -1885,7 +1885,7 @@ void Peep::FormatActionTo(Formatter& ft) const
}
break;
}
case PEEP_STATE_HEADING_TO_INSPECTION:
case PeepState::HeadingToInspection:
{
ft.Add<rct_string_id>(STR_HEADING_TO_RIDE_FOR_INSPECTION);
auto ride = get_ride(CurrentRide);
@ -1899,7 +1899,7 @@ void Peep::FormatActionTo(Formatter& ft) const
}
break;
}
case PEEP_STATE_INSPECTING:
case PeepState::Inspecting:
{
ft.Add<rct_string_id>(STR_INSPECTING_RIDE);
auto ride = get_ride(CurrentRide);
@ -2019,31 +2019,31 @@ void peep_thought_set_format_args(const rct_peep_thought* thought, Formatter& ft
}
/** rct2: 0x00982004 */
static constexpr const bool peep_allow_pick_up[] = {
true, // PEEP_STATE_FALLING
false, // PEEP_STATE_1
false, // PEEP_STATE_QUEUING_FRONT
false, // PEEP_STATE_ON_RIDE
false, // PEEP_STATE_LEAVING_RIDE
true, // PEEP_STATE_WALKING
true, // PEEP_STATE_QUEUING
false, // PEEP_STATE_ENTERING_RIDE
true, // PEEP_STATE_SITTING
true, // PEEP_STATE_PICKED
true, // PEEP_STATE_PATROLLING
true, // PEEP_STATE_MOWING
true, // PEEP_STATE_SWEEPING
false, // PEEP_STATE_ENTERING_PARK
false, // PEEP_STATE_LEAVING_PARK
true, // PEEP_STATE_ANSWERING
false, // PEEP_STATE_FIXING
false, // PEEP_STATE_BUYING
true, // PEEP_STATE_WATCHING
true, // PEEP_STATE_EMPTYING_BIN
true, // PEEP_STATE_USING_BIN
true, // PEEP_STATE_WATERING
true, // PEEP_STATE_HEADING_TO_INSPECTION
false, // PEEP_STATE_INSPECTING
static const std::map<PeepState, bool> peep_allow_pick_up{
{ PeepState::Falling, true },
{ PeepState::One, false },
{ PeepState::QueuingFront, false },
{ PeepState::OnRide, false },
{ PeepState::LeavingRide, false },
{ PeepState::Walking, true },
{ PeepState::Queuing, true },
{ PeepState::EnteringRide, false },
{ PeepState::Sitting, true },
{ PeepState::Picked, true },
{ PeepState::Patrolling, true },
{ PeepState::Mowing, true },
{ PeepState::Sweeping, true },
{ PeepState::EnteringPark, false },
{ PeepState::LeavingPark, false },
{ PeepState::Answering, true },
{ PeepState::Fixing, false },
{ PeepState::Buying, false },
{ PeepState::Watching, true },
{ PeepState::EmptyingBin, true },
{ PeepState::UsingBin, true },
{ PeepState::Watering, true },
{ PeepState::HeadingToInspection, true },
{ PeepState::Inspecting, false },
};
/**
@ -2053,7 +2053,7 @@ static constexpr const bool peep_allow_pick_up[] = {
*/
bool peep_can_be_picked_up(Peep* peep)
{
return peep_allow_pick_up[peep->State];
return peep_allow_pick_up.find(peep->State)->second;
}
enum
@ -2330,7 +2330,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
return;
}
if (peep->State == PEEP_STATE_QUEUING)
if (peep->State == PeepState::Queuing)
{
// Guest is in the ride queue.
peep->SubState = 11;
@ -2375,7 +2375,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
peep->CurrentRide = rideIndex;
peep->CurrentRideStation = stationNum;
peep->DaysInQueue = 0;
peep->SetState(PEEP_STATE_QUEUING);
peep->SetState(PeepState::Queuing);
peep->SubState = 11;
peep->TimeInQueue = 0;
if (peep->PeepFlags & PEEP_FLAGS_TRACKING)
@ -2418,7 +2418,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
}
// Peep is leaving the park.
if (peep->State != PEEP_STATE_WALKING)
if (peep->State != PeepState::Walking)
{
peep_return_to_centre_of_tile(peep);
return;
@ -2438,7 +2438,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
peep->DestinationY += CoordsDirectionDelta[peep->PeepDirection].y;
peep->DestinationTolerance = 9;
peep->MoveTo({ coords, peep->z });
peep->SetState(PEEP_STATE_LEAVING_PARK);
peep->SetState(PeepState::LeavingPark);
peep->Var37 = 0;
if (peep->PeepFlags & PEEP_FLAGS_TRACKING)
@ -2455,7 +2455,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
// Peep is entering the park.
if (peep->State != PEEP_STATE_ENTERING_PARK)
if (peep->State != PeepState::EnteringPark)
{
peep_return_to_centre_of_tile(peep);
return;
@ -2463,7 +2463,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
if (!(gParkFlags & PARK_FLAGS_PARK_OPEN))
{
peep->State = PEEP_STATE_LEAVING_PARK;
peep->State = PeepState::LeavingPark;
peep->Var37 = 1;
decrement_guests_heading_for_park();
peep_window_state_update(peep);
@ -2527,7 +2527,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
if (!found)
{
peep->State = PEEP_STATE_LEAVING_PARK;
peep->State = PeepState::LeavingPark;
peep->Var37 = 1;
decrement_guests_heading_for_park();
peep_window_state_update(peep);
@ -2555,7 +2555,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
}
if (entranceFee > peep->CashInPocket)
{
peep->State = PEEP_STATE_LEAVING_PARK;
peep->State = PeepState::LeavingPark;
peep->Var37 = 1;
decrement_guests_heading_for_park();
peep_window_state_update(peep);
@ -2631,7 +2631,7 @@ static void peep_footpath_move_forward(Peep* peep, const CoordsXYE& coords, bool
{
if (auto other_peep = entity->As<Peep>(); other_peep != nullptr)
{
if (other_peep->State != PEEP_STATE_WALKING)
if (other_peep->State != PeepState::Walking)
continue;
if (abs(other_peep->z - peep->NextLoc.z) > 16)
@ -2653,7 +2653,7 @@ static void peep_footpath_move_forward(Peep* peep, const CoordsXYE& coords, bool
}
}
if (crowded >= 10 && peep->State == PEEP_STATE_WALKING && (scenario_rand() & 0xFFFF) <= 21845)
if (crowded >= 10 && peep->State == PeepState::Walking && (scenario_rand() & 0xFFFF) <= 21845)
{
peep->InsertNewThought(PEEP_THOUGHT_TYPE_CROWDED, PEEP_THOUGHT_ITEM_NONE);
peep->HappinessTarget = std::max(0, peep->HappinessTarget - 14);
@ -2754,7 +2754,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
if (guest != nullptr && tile_element->AsPath()->IsQueue())
{
auto rideIndex = tile_element->AsPath()->GetRideIndex();
if (peep->State == PEEP_STATE_QUEUING)
if (peep->State == PeepState::Queuing)
{
// Check if this queue is connected to the ride the
// peep is queuing for, i.e. the player hasn't edited
@ -2768,7 +2768,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
// Queue got disconnected from the original ride.
peep->InteractionRideIndex = 0xFF;
guest->RemoveFromQueue();
peep->SetState(PEEP_STATE_1);
peep->SetState(PeepState::One);
peep_footpath_move_forward(peep, { coords, tile_element }, vandalism_present);
}
}
@ -2800,7 +2800,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
peep_decrement_num_riders(peep);
peep->CurrentRide = rideIndex;
peep->CurrentRideStation = stationNum;
peep->State = PEEP_STATE_QUEUING;
peep->State = PeepState::Queuing;
peep->DaysInQueue = 0;
peep_window_state_update(peep);
@ -2838,10 +2838,10 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
else
{
peep->InteractionRideIndex = 0xFF;
if (peep->State == PEEP_STATE_QUEUING)
if (peep->State == PeepState::Queuing)
{
peep->RemoveFromQueue();
peep->SetState(PEEP_STATE_1);
peep->SetState(PeepState::One);
}
peep_footpath_move_forward(peep, { coords, tile_element }, vandalism_present);
}
@ -2911,7 +2911,7 @@ static bool peep_interact_with_shop(Peep* peep, const CoordsXYE& coords)
peep->DestinationTolerance = 3;
peep->CurrentRide = rideIndex;
peep->SetState(PEEP_STATE_ENTERING_RIDE);
peep->SetState(PeepState::EnteringRide);
peep->SubState = PEEP_SHOP_APPROACH;
peep->GuestTimeOnRide = 0;
@ -2934,7 +2934,7 @@ static bool peep_interact_with_shop(Peep* peep, const CoordsXYE& coords)
if (peep->GuestHeadingToRideId == rideIndex)
peep->GuestHeadingToRideId = RIDE_ID_NULL;
peep->ActionSpriteImageOffset = _unk_F1AEF0;
peep->SetState(PEEP_STATE_BUYING);
peep->SetState(PeepState::Buying);
peep->CurrentRide = rideIndex;
peep->SubState = 0;
}
@ -2960,7 +2960,7 @@ void Peep::PerformNextAction(uint8_t& pathing_result, TileElement*& tile_result)
if (Action == PEEP_ACTION_NONE_1)
Action = PEEP_ACTION_NONE_2;
if (State == PEEP_STATE_QUEUING)
if (State == PeepState::Queuing)
{
if (peep_update_queue_position(this, previousAction))
return;
@ -3052,10 +3052,10 @@ void Peep::PerformNextAction(uint8_t& pathing_result, TileElement*& tile_result)
if (height <= 3 || (AssignedPeepType == PeepType::Staff && height <= 32))
{
InteractionRideIndex = 0xFF;
if (State == PEEP_STATE_QUEUING)
if (State == PeepState::Queuing)
{
RemoveFromQueue();
SetState(PEEP_STATE_1);
SetState(PeepState::One);
}
if (!map_is_location_in_park(newLoc))
@ -3315,7 +3315,7 @@ void Peep::RemoveFromQueue()
*/
void Peep::RemoveFromRide()
{
if (State == PEEP_STATE_QUEUING)
if (State == PeepState::Queuing)
{
RemoveFromQueue();
}

50
src/openrct2/peep/Peep.h
View File

@ -214,32 +214,32 @@ enum PeepThoughtType : uint8_t
PEEP_THOUGHT_TYPE_NONE = 255
};
enum PeepState : uint8_t
enum class PeepState : uint8_t
{
PEEP_STATE_FALLING = 0, // Drowning is part of falling
PEEP_STATE_1 = 1,
PEEP_STATE_QUEUING_FRONT = 2,
PEEP_STATE_ON_RIDE = 3,
PEEP_STATE_LEAVING_RIDE = 4,
PEEP_STATE_WALKING = 5,
PEEP_STATE_QUEUING = 6,
PEEP_STATE_ENTERING_RIDE = 7,
PEEP_STATE_SITTING = 8,
PEEP_STATE_PICKED = 9,
PEEP_STATE_PATROLLING = 10, // Not sure
PEEP_STATE_MOWING = 11,
PEEP_STATE_SWEEPING = 12,
PEEP_STATE_ENTERING_PARK = 13,
PEEP_STATE_LEAVING_PARK = 14,
PEEP_STATE_ANSWERING = 15,
PEEP_STATE_FIXING = 16,
PEEP_STATE_BUYING = 17,
PEEP_STATE_WATCHING = 18,
PEEP_STATE_EMPTYING_BIN = 19,
PEEP_STATE_USING_BIN = 20,
PEEP_STATE_WATERING = 21,
PEEP_STATE_HEADING_TO_INSPECTION = 22,
PEEP_STATE_INSPECTING = 23
Falling = 0, // Drowning is part of falling
One = 1, // was PEEP_STATE_1
QueuingFront = 2,
OnRide = 3,
LeavingRide = 4,
Walking = 5,
Queuing = 6,
EnteringRide = 7,
Sitting = 8,
Picked = 9,
Patrolling = 10, // Not sure
Mowing = 11,
Sweeping = 12,
EnteringPark = 13,
LeavingPark = 14,
Answering = 15,
Fixing = 16,
Buying = 17,
Watching = 18,
EmptyingBin = 19,
UsingBin = 20,
Watering = 21,
HeadingToInspection = 22,
Inspecting = 23
};
enum class PeepSittingSubState : uint8_t

75
src/openrct2/peep/Staff.cpp
View File

@ -667,7 +667,7 @@ bool Staff::DoHandymanPathFinding()
DestinationX = chosenTile.x + 16;
DestinationY = chosenTile.y + 16;
DestinationTolerance = 3;
if (State == PEEP_STATE_QUEUING)
if (State == PeepState::Queuing)
{
DestinationTolerance = (scenario_rand() & 7) + 2;
}
@ -721,8 +721,7 @@ Direction Staff::MechanicDirectionSurface() const
Direction direction = scenario_rand() & 3;
auto ride = get_ride(CurrentRide);
if (ride != nullptr && (State == PEEP_STATE_ANSWERING || State == PEEP_STATE_HEADING_TO_INSPECTION)
&& (scenario_rand() & 1))
if (ride != nullptr && (State == PeepState::Answering || State == PeepState::HeadingToInspection) && (scenario_rand() & 1))
{
auto location = ride_get_exit_location(ride, CurrentRideStation);
if (location.isNull())
@ -785,7 +784,7 @@ Direction Staff::MechanicDirectionPath(uint8_t validDirections, PathElement* pat
pathDirections &= ~(1 << direction);
if (pathDirections == 0)
{
if (State != PEEP_STATE_ANSWERING && State != PEEP_STATE_HEADING_TO_INSPECTION)
if (State != PeepState::Answering && State != PeepState::HeadingToInspection)
{
return direction;
}
@ -801,7 +800,7 @@ Direction Staff::MechanicDirectionPath(uint8_t validDirections, PathElement* pat
// Mechanic is heading to ride (either broken down or for inspection).
auto ride = get_ride(CurrentRide);
if (ride != nullptr && (State == PEEP_STATE_ANSWERING || State == PEEP_STATE_HEADING_TO_INSPECTION))
if (ride != nullptr && (State == PeepState::Answering || State == PeepState::HeadingToInspection))
{
/* Find location of the exit for the target ride station
* or if the ride has no exit, the entrance. */
@ -898,7 +897,7 @@ bool Staff::DoMechanicPathFinding()
Direction Staff::DirectionPath(uint8_t validDirections, PathElement* pathElement) const
{
uint8_t pathDirections = pathElement->GetEdges();
if (State != PEEP_STATE_ANSWERING && State != PEEP_STATE_HEADING_TO_INSPECTION)
if (State != PeepState::Answering && State != PeepState::HeadingToInspection)
{
pathDirections &= validDirections;
}
@ -994,11 +993,11 @@ void Staff::EntertainerUpdateNearbyPeeps() const
if (y_dist > 96)
continue;
if (guest->State == PEEP_STATE_WALKING)
if (guest->State == PeepState::Walking)
{
guest->HappinessTarget = std::min(guest->HappinessTarget + 4, PEEP_MAX_HAPPINESS);
}
else if (guest->State == PEEP_STATE_QUEUING)
else if (guest->State == PeepState::Queuing)
{
guest->TimeInQueue = std::max(0, guest->TimeInQueue - 200);
guest->HappinessTarget = std::min(guest->HappinessTarget + 3, PEEP_MAX_HAPPINESS);
@ -1381,20 +1380,20 @@ void Staff::UpdateHeadingToInspect()
auto ride = get_ride(CurrentRide);
if (ride == nullptr)
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
if (ride_get_exit_location(ride, CurrentRideStation).isNull())
{
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
if (ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING || !(ride->lifecycle_flags & RIDE_LIFECYCLE_DUE_INSPECTION))
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
@ -1414,7 +1413,7 @@ void Staff::UpdateHeadingToInspect()
{
ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
}
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
@ -1475,7 +1474,7 @@ void Staff::UpdateHeadingToInspect()
return;
}
SetState(PEEP_STATE_INSPECTING);
SetState(PeepState::Inspecting);
SubState = 0;
}
@ -1488,7 +1487,7 @@ void Staff::UpdateAnswering()
auto ride = get_ride(CurrentRide);
if (ride == nullptr || ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING)
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
@ -1525,7 +1524,7 @@ void Staff::UpdateAnswering()
{
ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
@ -1586,7 +1585,7 @@ void Staff::UpdateAnswering()
return;
}
SetState(PEEP_STATE_FIXING);
SetState(PeepState::Fixing);
SubState = 0;
}
@ -1653,7 +1652,7 @@ bool Staff::UpdatePatrollingFindWatering()
}
}
SetState(PEEP_STATE_WATERING);
SetState(PeepState::Watering);
Var37 = chosen_position;
SubState = 0;
@ -1723,7 +1722,7 @@ bool Staff::UpdatePatrollingFindBin()
return false;
Var37 = chosen_position;
SetState(PEEP_STATE_EMPTYING_BIN);
SetState(PeepState::EmptyingBin);
SubState = 0;
DestinationX = (x & 0xFFE0) + BinUseOffsets[chosen_position].x;
@ -1752,7 +1751,7 @@ bool Staff::UpdatePatrollingFindGrass()
{
if ((surfaceElement->GetGrassLength() & 0x7) >= GRASS_LENGTH_CLEAR_1)
{
SetState(PEEP_STATE_MOWING);
SetState(PeepState::Mowing);
Var37 = 0;
// Original code used .y for both x and y. Changed to .x to make more sense (both x and y are 28)
DestinationX = NextLoc.x + _MowingWaypoints[0].x;
@ -1780,7 +1779,7 @@ bool Staff::UpdatePatrollingFindSweeping()
if (z_diff >= 16)
continue;
SetState(PEEP_STATE_SWEEPING);
SetState(PeepState::Sweeping);
Var37 = 0;
DestinationX = litter->x;
@ -1798,7 +1797,7 @@ void Staff::Tick128UpdateStaff()
return;
PeepSpriteType newSpriteType = PEEP_SPRITE_TYPE_SECURITY_ALT;
if (State != PEEP_STATE_PATROLLING)
if (State != PeepState::Patrolling)
newSpriteType = PEEP_SPRITE_TYPE_SECURITY;
if (SpriteType == newSpriteType)
@ -1831,31 +1830,31 @@ void Staff::UpdateStaff(uint32_t stepsToTake)
{
switch (State)
{
case PEEP_STATE_PATROLLING:
case PeepState::Patrolling:
UpdatePatrolling();
break;
case PEEP_STATE_MOWING:
case PeepState::Mowing:
UpdateMowing();
break;
case PEEP_STATE_SWEEPING:
case PeepState::Sweeping:
UpdateSweeping();
break;
case PEEP_STATE_ANSWERING:
case PeepState::Answering:
UpdateAnswering();
break;
case PEEP_STATE_FIXING:
case PeepState::Fixing:
UpdateFixing(stepsToTake);
break;
case PEEP_STATE_INSPECTING:
case PeepState::Inspecting:
UpdateFixing(stepsToTake);
break;
case PEEP_STATE_EMPTYING_BIN:
case PeepState::EmptyingBin:
UpdateEmptyingBin();
break;
case PEEP_STATE_WATERING:
case PeepState::Watering:
UpdateWatering();
break;
case PEEP_STATE_HEADING_TO_INSPECTION:
case PeepState::HeadingToInspection:
UpdateHeadingToInspect();
break;
default:
@ -1889,7 +1888,7 @@ void Staff::UpdatePatrolling()
if (water_height > 0)
{
MoveTo({ x, y, water_height });
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
}
@ -2020,19 +2019,19 @@ void Staff::UpdateFixing(int32_t steps)
auto ride = get_ride(CurrentRide);
if (ride == nullptr)
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return;
}
bool progressToNextSubstate = true;
bool firstRun = true;
if ((State == PEEP_STATE_INSPECTING)
if ((State == PeepState::Inspecting)
&& (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)))
{
// Ride has broken down since Mechanic was called to inspect it.
// Mechanic identifies the breakdown and switches to fixing it.
State = PEEP_STATE_FIXING;
State = PeepState::Fixing;
}
while (progressToNextSubstate)
@ -2106,7 +2105,7 @@ void Staff::UpdateFixing(int32_t steps)
int32_t subState = SubState;
uint32_t sub_state_sequence_mask = FixingSubstatesForBreakdown[8];
if (State != PEEP_STATE_INSPECTING)
if (State != PeepState::Inspecting)
{
sub_state_sequence_mask = FixingSubstatesForBreakdown[ride->breakdown_reason_pending];
}
@ -2572,7 +2571,7 @@ bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* r
{
ride->mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
if (State == PEEP_STATE_INSPECTING)
if (State == PeepState::Inspecting)
{
UpdateRideInspected(CurrentRide);
@ -2621,7 +2620,7 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
if (exitPosition.isNull())
{
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return false;
}
}
@ -2650,7 +2649,7 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
MoveTo({ *loc, stationHeight });
return false;
}
SetState(PEEP_STATE_FALLING);
SetState(PeepState::Falling);
return false;
}

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

@ -1561,7 +1561,7 @@ private:
if (dst->AssignedPeepType == PeepType::Guest)
{
if (dst->OutsideOfPark && dst->State != PEEP_STATE_LEAVING_PARK)
if (dst->OutsideOfPark && dst->State != PeepState::LeavingPark)
{
increment_guests_heading_for_park();
}
@ -3040,10 +3040,10 @@ private:
// First, make the queuing peep exit
for (auto peep : EntityList<Guest>(EntityListId::Peep))
{
if (peep->State == PEEP_STATE_QUEUING_FRONT && peep->CurrentRide == 0)
if (peep->State == PeepState::QueuingFront && peep->CurrentRide == 0)
{
peep->RemoveFromQueue();
peep->SetState(PEEP_STATE_FALLING);
peep->SetState(PeepState::Falling);
break;
}
}

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

@ -1024,7 +1024,8 @@ public:
if (sprite.unknown.sprite_identifier == SPRITE_IDENTIFIER_PEEP)
{
if (sprite.peep.current_ride == rideIndex
&& (sprite.peep.state == PEEP_STATE_ON_RIDE || sprite.peep.state == PEEP_STATE_ENTERING_RIDE))
&& (static_cast<PeepState>(sprite.peep.state) == PeepState::OnRide
|| static_cast<PeepState>(sprite.peep.state) == PeepState::EnteringRide))
{
numRiders++;
}

26
src/openrct2/ride/Ride.cpp
View File

@ -1121,14 +1121,14 @@ void ride_remove_peeps(Ride* ride)
// Place all the peeps at exit
for (auto peep : EntityList<Peep>(EntityListId::Peep))
{
if (peep->State == PEEP_STATE_QUEUING_FRONT || peep->State == PEEP_STATE_ENTERING_RIDE
|| peep->State == PEEP_STATE_LEAVING_RIDE || peep->State == PEEP_STATE_ON_RIDE)
if (peep->State == PeepState::QueuingFront || peep->State == PeepState::EnteringRide
|| peep->State == PeepState::LeavingRide || peep->State == PeepState::OnRide)
{
if (peep->CurrentRide != ride->id)
continue;
peep_decrement_num_riders(peep);
if (peep->State == PEEP_STATE_QUEUING_FRONT && peep->SubState == PEEP_RIDE_AT_ENTRANCE)
if (peep->State == PeepState::QueuingFront && peep->SubState == PEEP_RIDE_AT_ENTRANCE)
peep->RemoveFromQueue();
if (exitPosition.direction == INVALID_DIRECTION)
@ -1145,7 +1145,7 @@ void ride_remove_peeps(Ride* ride)
peep->sprite_direction = exitPosition.direction;
}
peep->State = PEEP_STATE_FALLING;
peep->State = PeepState::Falling;
peep->SwitchToSpecialSprite(0);
peep->Happiness = std::min(peep->Happiness, peep->HappinessTarget) / 2;
@ -2616,7 +2616,7 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
{
auto mechanic = ride_get_mechanic(ride);
if (mechanic == nullptr
|| (mechanic->State != PEEP_STATE_HEADING_TO_INSPECTION && mechanic->State != PEEP_STATE_ANSWERING)
|| (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Answering)
|| mechanic->CurrentRide != ride->id)
{
ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
@ -2629,8 +2629,8 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
{
auto mechanic = ride_get_mechanic(ride);
if (mechanic == nullptr
|| (mechanic->State != PEEP_STATE_HEADING_TO_INSPECTION && mechanic->State != PEEP_STATE_FIXING
&& mechanic->State != PEEP_STATE_INSPECTING && mechanic->State != PEEP_STATE_ANSWERING))
|| (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Fixing
&& mechanic->State != PeepState::Inspecting && mechanic->State != PeepState::Answering))
{
ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
@ -2647,7 +2647,7 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
*/
static void ride_call_mechanic(Ride* ride, Peep* mechanic, int32_t forInspection)
{
mechanic->SetState(forInspection ? PEEP_STATE_HEADING_TO_INSPECTION : PEEP_STATE_ANSWERING);
mechanic->SetState(forInspection ? PeepState::HeadingToInspection : PeepState::Answering);
mechanic->SubState = 0;
ride->mechanic_status = RIDE_MECHANIC_STATUS_HEADING;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
@ -2709,12 +2709,12 @@ Peep* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspect
if (!forInspection)
{
if (peep->State == PEEP_STATE_HEADING_TO_INSPECTION)
if (peep->State == PeepState::HeadingToInspection)
{
if (peep->SubState >= 4)
continue;
}
else if (peep->State != PEEP_STATE_PATROLLING)
else if (peep->State != PeepState::Patrolling)
continue;
if (!(peep->StaffOrders & STAFF_ORDERS_FIX_RIDES))
@ -2722,7 +2722,7 @@ Peep* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspect
}
else
{
if (peep->State != PEEP_STATE_PATROLLING || !(peep->StaffOrders & STAFF_ORDERS_INSPECT_RIDES))
if (peep->State != PeepState::Patrolling || !(peep->StaffOrders & STAFF_ORDERS_INSPECT_RIDES))
continue;
}
@ -5471,13 +5471,13 @@ void Ride::StopGuestsQueuing()
{
for (auto peep : EntityList<Guest>(EntityListId::Peep))
{
if (peep->State != PEEP_STATE_QUEUING)
if (peep->State != PeepState::Queuing)
continue;
if (peep->CurrentRide != id)
continue;
peep->RemoveFromQueue();
peep->SetState(PEEP_STATE_FALLING);
peep->SetState(PeepState::Falling);
}
}

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

@ -4101,7 +4101,7 @@ void Vehicle::UpdateUnloadingPassengers()
if (firstGuest != nullptr)
{
firstGuest->SetState(PEEP_STATE_LEAVING_RIDE);
firstGuest->SetState(PeepState::LeavingRide);
firstGuest->SubState = PEEP_RIDE_LEAVE_VEHICLE;
}
@ -4110,7 +4110,7 @@ void Vehicle::UpdateUnloadingPassengers()
if (secondGuest != nullptr)
{
secondGuest->SetState(PEEP_STATE_LEAVING_RIDE);
secondGuest->SetState(PeepState::LeavingRide);
secondGuest->SubState = PEEP_RIDE_LEAVE_VEHICLE;
}
}
@ -4146,7 +4146,7 @@ void Vehicle::UpdateUnloadingPassengers()
Peep* curPeep = GetEntity<Guest>(train->peep[peepIndex]);
if (curPeep != nullptr)
{
curPeep->SetState(PEEP_STATE_LEAVING_RIDE);
curPeep->SetState(PeepState::LeavingRide);
curPeep->SubState = PEEP_RIDE_LEAVE_VEHICLE;
}
}

2
src/openrct2/ride/gentle/FerrisWheel.cpp
View File

@ -105,7 +105,7 @@ static void paint_ferris_wheel_structure(
for (int32_t i = 0; i < 32; i += 2)
{
auto* peep = GetEntity<Guest>(vehicle->peep[i]);
if (peep == nullptr || peep->State != PEEP_STATE_ON_RIDE)
if (peep == nullptr || peep->State != PeepState::OnRide)
{
continue;
}

2
src/openrct2/scripting/ScEntity.hpp
View File

@ -142,7 +142,7 @@ namespace OpenRCT2::Scripting
auto peep = static_cast<Peep*>(entity);
// We can't remove a single peep from a ride at the moment as this can cause complications with the
// vehicle car having an unsupported peep capacity.
if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
{
duk_error(ctx, DUK_ERR_ERROR, "Removing a peep that is on a ride is currently unsupported.");
}

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

@ -417,11 +417,11 @@ void footpath_interrupt_peeps(const CoordsXYZ& footpathPos)
auto quad = EntityTileList<Peep>(footpathPos);
for (auto peep : quad)
{
if (peep->State == PEEP_STATE_SITTING || peep->State == PEEP_STATE_WATCHING)
if (peep->State == PeepState::Sitting || peep->State == PeepState::Watching)
{
if (peep->z == footpathPos.z)
{
peep->SetState(PEEP_STATE_WALKING);
peep->SetState(PeepState::Walking);
peep->DestinationX = (peep->x & 0xFFE0) + 16;
peep->DestinationY = (peep->y & 0xFFE0) + 16;
peep->DestinationTolerance = 5;

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

@ -194,7 +194,7 @@ static bool map_animation_invalidate_small_scenery(const CoordsXYZ& loc)
auto quad = EntityTileList<Peep>(CoordsXY{ loc } - CoordsDirectionDelta[direction]);
for (auto peep : quad)
{
if (peep->State != PEEP_STATE_WALKING)
if (peep->State != PeepState::Walking)
continue;
if (peep->z != loc.z)
continue;

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

@ -729,7 +729,7 @@ Peep* Park::GenerateGuest()
peep->DestinationTolerance = 5;
peep->PeepDirection = direction;
peep->Var37 = 0;
peep->State = PEEP_STATE_ENTERING_PARK;
peep->State = PeepState::EnteringPark;
}
}
return peep;

10
test/tests/PlayTests.cpp
View File

@ -118,7 +118,7 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
richGuest->CashInPocket = 3000;
// Wait for rich guest to get in queue
bool matched = updateUntil(*gs, 1000, [&]() { return richGuest->State == PEEP_STATE_QUEUING; });
bool matched = updateUntil(*gs, 1000, [&]() { return richGuest->State == PeepState::Queuing; });
ASSERT_TRUE(matched);
// Insert poor guest
@ -126,7 +126,7 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
poorGuest->CashInPocket = 5;
// Wait for poor guest to get in queue
matched = updateUntil(*gs, 1000, [&]() { return poorGuest->State == PEEP_STATE_QUEUING; });
matched = updateUntil(*gs, 1000, [&]() { return poorGuest->State == PeepState::Queuing; });
ASSERT_TRUE(matched);
// Raise the price of the ride to a value poor guest can't pay
@ -136,8 +136,8 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
// since it doesn't have enough money to pay for it
bool enteredTheRide = false;
matched = updateUntil(*gs, 10000, [&]() {
enteredTheRide |= poorGuest->State == PEEP_STATE_ON_RIDE;
return poorGuest->State == PEEP_STATE_WALKING || enteredTheRide;
enteredTheRide |= poorGuest->State == PeepState::OnRide;
return poorGuest->State == PeepState::Walking || enteredTheRide;
});
ASSERT_TRUE(matched);
@ -181,7 +181,7 @@ TEST_F(PlayTests, CarRideWithOneCarOnlyAcceptsTwoGuests)
}
// Wait until one of them is riding
auto guestIsOnRide = [](auto* g) { return g->State == PEEP_STATE_ON_RIDE; };
auto guestIsOnRide = [](auto* g) { return g->State == PeepState::OnRide; };
bool matched = updateUntil(*gs, 10000, [&]() { return std::any_of(guests.begin(), guests.end(), guestIsOnRide); });
ASSERT_TRUE(matched);